public async Task <IActionResult> Create([Bind("Id,SaRacuna,NaRacun,Vrijeme,Iznos,VrstaTransakcije,NacinTransakcije")] Transakcija transakcija)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _transakcije.Pristupi(korisnik);
            _racuni.Pristupi(korisnik);

            transakcija.SaRacuna = await _racuni.DajRacun(transakcija.SaRacuna.Id);

            if (transakcija.NacinTransakcije == NacinTransakcije.Interna)
            {
                transakcija.NaRacun = await _racuni.DajRacun(transakcija.NaRacun.Id);
            }
            else
            {
                transakcija.NaRacun = await _racuni.DajRacun(4);
            }

            if (transakcija.SaRacuna.StanjeRacuna < transakcija.Iznos)
            {
                return(RedirectToAction(nameof(Create), new { area = "nemaSredstava" }));
            }

            await _transakcije.Uplati(transakcija);

            return(RedirectToAction("Index", "KlijentHome", new { area = "" }));
        }
        // GET: Filijala/Details/5
        public async Task <IActionResult> Details(int?id)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _filijaleBankomati.Pristupi(korisnik);
            ViewData["Ime"] = korisnik.Ime;
            if (id == null)
            {
                return(NotFound());
            }

            var filijala = await _filijaleBankomati.DajFilijalu(id);

            if (filijala == null)
            {
                return(NotFound());
            }

            return(View(filijala));
        }
        public async Task <IActionResult> Edit(int?id)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _racuni.Pristupi(korisnik);


            if (id == null)
            {
                return(NotFound());
            }

            var racun = await _racuni.DajRacun(id);

            if (racun == null)
            {
                return(NotFound());
            }
            return(View(racun));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,StanjeRacuna")] Racun racun)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _racuni.Pristupi(korisnik);

            if (id != racun.Id)
            {
                return(NotFound());
            }


            try
            {
                await _racuni.UrediStanjeRacuna(racun);
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!RacunExists(racun.Id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }
            return(RedirectToAction(nameof(Index)));
        }
Beispiel #5
0
        // GET: AdministratorBankari/Delete/5
        public async Task <IActionResult> Delete(int?id)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _bankari.Pristupi(korisnik);
            ViewData["Ime"] = korisnik.Ime;

            if (id == null)
            {
                return(NotFound());
            }

            var bankar = await _bankari.DajBankara(id);

            if (bankar == null)
            {
                return(NotFound());
            }

            return(View(bankar));
        }
Beispiel #6
0
        // GET: BankarZahtjevZaKredit/Details/5
        public async Task <IActionResult> Details(int?id)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _zahtjevi.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;

            if (id == null)
            {
                return(NotFound());
            }

            var zahtjev = await _zahtjevi.DajZahtjev(id);

            if (zahtjev == null)
            {
                return(NotFound());
            }

            ViewData["kreditnaSposobnost"] = zahtjev.DajKreditnuSposobnost();

            return(View(zahtjev));
        }
        // GET: BankarTransakcije/Details/5
        public async Task <IActionResult> Details(int?id)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _transakcije.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;

            if (id == null)
            {
                return(NotFound());
            }

            var transakcija = await _transakcije.DajTransakciju(id);

            if (transakcija == null)
            {
                return(NotFound());
            }

            return(View(transakcija));
        }
Beispiel #8
0
        // GET: AdministratorNovosti/Details/5
        public async Task <IActionResult> Details(int?id)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _novosti.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;

            if (id == null)
            {
                return(NotFound());
            }

            var novost = await _novosti.DajNovost(id);

            if (novost == null)
            {
                return(NotFound());
            }

            return(View(novost));
        }
Beispiel #9
0
        // GET: KlijentProfil
        public async Task <IActionResult> Index()
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _klijenti.Pristupi(korisnik);
            _transakcije.Pristupi(korisnik);
            _krediti.Pristupi(korisnik);

            ViewData["Id"] = korisnik.Id;


            var klijent = await _klijenti.DajKlijenta(korisnik.Id);

            if (klijent == null)
            {
                return(NotFound());
            }

            ViewData["transakcije"] = await _transakcije.DajTransakcije(korisnik.Id);

            ViewData["racuni"] = await _racuni.DajRacune(korisnik.Id);

            ViewData["krediti"] = await _krediti.DajSveKrediteKlijenta(korisnik.Id);

            return(View(klijent));
        }
        public async Task <IActionResult> Index()
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }
            ViewData["Ime"] = korisnik.Ime;
            return(View(korisnik));
        }
        // GET: Bankomat/Create
        public async Task <IActionResult> CreateAsync()
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _filijaleBankomati.Pristupi(korisnik);
            @ViewData["Ime"] = korisnik.Ime;
            return(View());
        }
        // GET: BankarTransakcije
        public async Task <IActionResult> Index()
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _transakcije.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;

            return(View(await _transakcije.DajSveTransakcije()));
        }
Beispiel #13
0
        // GET: KlijentZahtjevZaKredit/Create
        public async Task <IActionResult> Create()
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _zahtjevi.Pristupi(korisnik);
            _racuni.Pristupi(korisnik);
            ViewData["racuni"] = await _racuni.DajSveRacuneKlijenta(korisnik.Id);

            return(View());
        }
        public async Task <IActionResult> DeleteConfirmed(int id)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _filijaleBankomati.Pristupi(korisnik);
            ViewData["Ime"] = korisnik.Ime;
            await _filijaleBankomati.UkloniBankomat(id);

            return(RedirectToAction(nameof(Index)));
        }
        // GET: Kredit
        public async Task <IActionResult> Index()
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _krediti.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;
            var krediti = await _krediti.DajSveKredite();

            return(View(krediti));
        }
Beispiel #16
0
        public async Task <IActionResult> Odbij(int id)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _zahtjevi.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;

            await _zahtjevi.RijesiZahtjev(id, false);

            return(RedirectToAction(nameof(Index)));
        }
Beispiel #17
0
        public async Task <IActionResult> Create([Bind("NamjenaKredita,MjesecniPrihodi,ProsjecniTroskoviDomacinstva,NazivRadnogMjesta,NazivPoslodavca,RadniStaz,BrojNekretnina,BracnoStanje,SupruznikIme,SupruznikPrezime,SupruznikZanimanje,ImaNeplacenihDugova,BrojNeplacenihDugova,StatusZahtjeva,Iznos,KamatnaStopa,RokOtplate,Racun")] ZahtjevZaKredit zahtjevZaKredit)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _zahtjevi.Pristupi(korisnik);
            _racuni.Pristupi(korisnik);

            zahtjevZaKredit.Racun = await _racuni.DajRacun(zahtjevZaKredit.Racun.Id);

            await _zahtjevi.PodnesiZahtjevZaKredit(zahtjevZaKredit);

            return(RedirectToAction("Index", "KlijentHome", new { area = "" }));
        }
        // GET: KlijentTransakcija/Create
        public async Task <IActionResult> Create(string area = "")
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _transakcije.Pristupi(korisnik);
            _racuni.Pristupi(korisnik);

            ViewData["nemaSredstava"] = area.Equals("nemaSredstava");

            ViewData["racuni"] = await _racuni.DajSveRacuneKlijenta(korisnik.Id);

            return(View());
        }
        public async Task <IActionResult> Create([Bind("Ime,Adresa")] Bankomat bankomat)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _filijaleBankomati.Pristupi(korisnik);
            ViewData["Ime"] = korisnik.Ime;
            if (ModelState.IsValid)
            {
                await _filijaleBankomati.DodajBankomat(bankomat);

                return(RedirectToAction(nameof(Index)));
            }
            return(View(bankomat));
        }
Beispiel #20
0
        public async Task <IActionResult> Create([Bind("Ime,Prezime,KorisnickoIme,Lozinka,MjestoZaposlenja")] Bankar bankar)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _bankari.Pristupi(korisnik);
            ViewData["Ime"] = korisnik.Ime;

            if (ModelState.IsValid)
            {
                await _bankari.DodajBankara(bankar);

                return(RedirectToAction(nameof(Index)));
            }
            return(View(bankar));
        }
Beispiel #21
0
        public async Task <IActionResult> Create([Bind("vrijemeDodavanja,Naslov,Sadrzaj,Prikazana")] Novost novost)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _novosti.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;

            if (ModelState.IsValid)
            {
                await _novosti.DodajNovost(novost);

                return(RedirectToAction(nameof(Index)));
            }
            return(View(novost));
        }
        public async Task <IActionResult> Create([Bind("DatumRodjenja,JMBG,BrojTelefona,BrojLicneKarte,Zanimanje,Ime,Prezime,KorisnickoIme,Lozinka,Adresa")] Klijent klijent)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _klijenti.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;

            if (ModelState.IsValid)
            {
                await _klijenti.DodajKlijenta(klijent);

                return(RedirectToAction(nameof(Index)));
            }
            return(View(klijent));
        }
Beispiel #23
0
        public async Task <IActionResult> Index()
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _klijenti.Pristupi(korisnik);
            _oglasnaPloca.Pristupi(korisnik);
            _filijaleBankomatiProxy.Pristupi(korisnik);

            ViewData["ime"] = korisnik.Ime;

            ViewData["bankomati"] = await _filijaleBankomatiProxy.DajSveBankomate();

            ViewData["filijale"] = await _filijaleBankomatiProxy.DajSveFilijale();

            return(View(await _oglasnaPloca.DajSvePrikazaneNovosti()));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,DatumRodjenja,JMBG,BrojTelefona,BrojLicneKarte,Zanimanje,Ime,Prezime,Spol,KorisnickoIme,Lozinka,Adresa, Grad, Drzava")] Klijent klijent)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _klijenti.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;

            if (id != klijent.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    await _klijenti.UrediKlijenta(klijent);
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!KlijentExists(klijent.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(klijent));
        }
Beispiel #25
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,vrijemeDodavanja,Naslov,Sadrzaj,Prikazana")] Novost novost)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _novosti.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;

            if (id != novost.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    await _novosti.UrediNovost(novost);
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!NovostExists(novost.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(novost));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Ime,Adresa")] Bankomat bankomat)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _filijaleBankomati.Pristupi(korisnik);
            ViewData["Ime"] = korisnik.Ime;

            if (id != bankomat.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    await _filijaleBankomati.UrediBankomat(bankomat);
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!BankomatExists(bankomat.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(bankomat));
        }
Beispiel #27
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Ime,Prezime,KorisnickoIme,Lozinka,MjestoZaposlenja")] Bankar bankar)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _bankari.Pristupi(korisnik);
            ViewData["Ime"] = korisnik.Ime;

            if (id != bankar.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    await _bankari.UrediBankara(bankar);
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!BankarExists(bankar.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(bankar));
        }
        public async Task <IActionResult> Create([Bind("Id,StanjeRacuna,VrstaRacuna,Klijent")] Racun racun)
        {
            korisnik = await LoginUtils.Authenticate(Request, Context, this);

            if (korisnik == null)
            {
                return(RedirectToAction("Logout", "Login", new { area = "" }));
            }

            _racuni.Pristupi(korisnik);

            ViewData["Ime"] = korisnik.Ime;

            Klijent klijent = await _klijenti.DajKlijentaLK(racun.Klijent.BrojLicneKarte);

            if (klijent != null)
            {
                racun.Klijent = klijent;
                await _racuni.OtvoriRacun(racun);

                return(RedirectToAction(nameof(Index)));
            }
            return(View(racun));
        }