Example #1
0
        public async Task <ServiceResult <KorisnikModel> > Kreiraj(KreirajKorisnikaRequestModel model)
        {
            model.KorisnickoIme = model.KorisnickoIme.Trim().ToLower();

            //Provjeri da li je korisničko ime zauzeto
            if (context.Users.FirstOrDefault(x => x.UserName == model.KorisnickoIme) != null)
            {
                return(Error("Korisničko ime zauzeto."));
            }

            var trenutni = authService.TrenutniKorisnik();

            // Provjeriti pravo dodavanja uloge
            var dozvoljeneUloge = pravoUpravljanjaKorisnikomService.VratiPravaUpravljanjaKorisnikom(trenutni.TrenutnaUlogaId);

            if (model.Uloge.Any(a => dozvoljeneUloge.All(doz => doz.UlogaUpravljanogId != a.VrstaUlogeId)))
            {
                return(Error("Nemate prava da dodate korisnika sa tim ulogama"));
            }

            var korisnik = new IdentityKorisnik
            {
                UserName           = model.KorisnickoIme,
                NormalizedUserName = model.KorisnickoIme.ToUpper(),
                Email           = model.Email,
                EmailConfirmed  = false,
                NormalizedEmail = model.Email.ToUpper(),
                PunoIme         = model.PunoIme,
                Roles           = new List <KorisnikUloga>(),
                SecurityStamp   = new Guid().ToString()
            };

            var passwordHasher = new PasswordHasher <IdentityKorisnik>();
            var hashed         = passwordHasher.HashPassword(korisnik, model.Lozinka);

            korisnik.PasswordHash = hashed;
            var userStore = new UserStore <IdentityKorisnik, Entities.Models.Korisnik.Uloga, Context, int, IdentityUserClaim <int>, KorisnikUloga, IdentityUserLogin <int>, IdentityUserToken <int>, IdentityRoleClaim <int> >(context);
            await userStore.CreateAsync(korisnik);

            SaveChanges(context);

            foreach (var uloga in model.Uloge)
            {
                var korisnikUloga = new KorisnikUloga
                {
                    RoleId = uloga.VrstaUlogeId,
                    UserId = korisnik.Id,
                    KorisnikUlogaDodatnaInformacija = new List <KorisnikUlogaDodatnaInformacija>()
                };

                context.UserRoles.Add(korisnikUloga);
            }

            SaveChanges(context);

            return(VratiKorisnikaPoKorisnickomImenu(korisnik.UserName));
        }
Example #2
0
        //[ClaimRequirement(ClaimTypes.UserData, "korisnik_korisnik_dodavanje")]
        public async Task <IActionResult> Kreiraj([FromBody] KreirajKorisnikaRequestModel model)
        {
            var result = await korisnikService.Kreiraj(model);

            if (result.IsOk)
            {
                logService.Akcija(Core.Constants.LogLevel.Info,
                                  Core.Constants.LogKategorija.korisnik,
                                  Core.Constants.LogAkcija.korisnik_dodaj,
                                  "KorisnickoIme: " + result.Value.KorisnickoIme,
                                  authService.TrenutniKorisnik().UserName
                                  );
            }
            return(Convert(result));
        }
Example #3
0
        public ServiceResult <KorisnikModel> Kreiraj(KreirajKorisnikaRequestModel model)
        {
            model.KorisnickoIme = model.KorisnickoIme.Trim().ToLower();

            if (model.Uloge == null || !model.Uloge.Any()) //null ili prazna lista
            {
                return(Error("Ne može se dodati korisnik bez definisane uloge."));
            }

            //Provjeri da li je korisničko ime zauzeto
            if (context.Korisnici.Include(k => k.KorisnikUloge).FirstOrDefault(x => x.KorisnickoIme == model.KorisnickoIme) != null)
            {
                return(Error("Korisničko ime zauzeto."));
            }

            var trenutni = authService.TrenutniKorisnik();

            // Provjeriti pravo dodavanja uloge
            var dozvoljeneUloge = pravoUpravljanjaKorisnikomService.VratiPravaUpravljanjaKorisnikom(trenutni.TrenutnaUlogaId);

            if (model.Uloge.Any(a => dozvoljeneUloge.All(doz => doz.UlogaUpravljanogId != a.VrstaUlogeId)))
            {
                return(Error("Nemate prava da dodate korisnika sa tim ulogama"));
            }

            var hashProvider = Scope.Resolve <IHashProvider>();
            var tajna        = hashProvider.HashPassword(model.Lozinka);

            Entities.Models.Korisnik.Korisnik korisnik = new Entities.Models.Korisnik.Korisnik
            {
                KorisnickoIme  = model.KorisnickoIme,
                Tajna          = tajna,
                DatumKreiranja = DateTime.Now,
                Email          = model.Email,
                PunoIme        = model.PunoIme,
                PolId          = model.PolId,
                KorisnikUloge  = new List <KorisnikUloga>(),
                Onemogucen     = false,
                Jezik          = (int)Jezici.bs
            };

            try
            {
                foreach (var uloga in model.Uloge)
                {
                    var korisnikUloga = new KorisnikUloga
                    {
                        UlogaId = uloga.VrstaUlogeId,
                        KorisnikUlogaDodatnaInformacija = new List <KorisnikUlogaDodatnaInformacija>()
                    };

                    korisnik.KorisnikUloge.Add(korisnikUloga);
                }
                context.Add(korisnik);


                //SaveChanges(context);



                var korisnikUloge = korisnik.KorisnikUloge.ToList();

                var korisnikUlogaNajveca = korisnikUloge[0].KorisnikUlogaId;

                //provjera koja vrsta uloge se dodaje
                var vrijednostUAplikaciji = context.Uloge.Where(u => u.Id == model.Uloge[0].VrstaUlogeId).Select(u => u.VrijednostUAplikaciji).FirstOrDefault();

                if (vrijednostUAplikaciji == (int)Uloga.Support)
                {
                    var kategorije = new List <int>();

                    foreach (var kat in model.Kategorije)
                    {
                        kategorije.Add(kat.ZahtjevKategorijaId);
                    }
                    var projekti = context.ZahtjevKategorije.Where(z => kategorije.Contains(z.Id)).Select(z => z.DioProjekta.ProjekatId).Distinct();

                    foreach (var projekat in projekti)
                    {
                        var korisnikProjekat = new KorisnikProjekat
                        {
                            ProjekatId      = projekat,
                            KorisnikUlogaId = korisnikUlogaNajveca
                        };

                        context.KorisnikProjekti.Add(korisnikProjekat);
                    }
                    foreach (var kategorija in kategorije)
                    {
                        var zahtjevKategorija = new KorisnikKategorija
                        {
                            KorisnickoIme       = model.KorisnickoIme,
                            ZahtjevKategorijaId = kategorija
                        };

                        context.KorisnikKategorije.Add(zahtjevKategorija);
                    }
                }
                else if (vrijednostUAplikaciji != (int)Uloga.Administrator)
                {
                    var korisnikProjekti = context.KorisnikProjekti.ToList();

                    foreach (var projekat in model.Projekti)
                    {
                        var korisnikProjekat = new KorisnikProjekat
                        {
                            ProjekatId      = projekat.ProjekatId,
                            KorisnikUlogaId = korisnikUlogaNajveca
                        };

                        context.KorisnikProjekti.Add(korisnikProjekat);
                    }
                }


                SaveChanges(context);
            }
            catch (Exception e)
            {
                return(Error("Greška", false));
            }
            return(VratiKorisnikaPoKorisnickomImenu(korisnik.KorisnickoIme));
        }