Example #1
0
        public static async Task <PenztarTetelDto> GetAsync(ossContext context, string sid, int key)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PENZTAR);

            var entity = await PenztarTetelDal.GetAsync(context, key);

            return(ObjectUtils.Convert <Models.Penztartetel, PenztarTetelDto>(entity));
        }
Example #2
0
        public static async Task <List <FelhasznaloDto> > ReadAsync(ossContext context, string sid, string maszk)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.FELHASZNALO);

            var entities = await FelhasznaloDal.ReadAsync(context, maszk);

            return(ObjectUtils.Convert <Models.Felhasznalo, FelhasznaloDto>(entities));
        }
Example #3
0
        public static async Task <AjanlatkeresDto> GetAsync(ossContext context, string sid, int key)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.AJANLATKERES);

            var entity = await AjanlatkeresDal.GetAsync(context, key);

            return(ObjectUtils.Convert <Models.Ajanlatkeres, AjanlatkeresDto>(entity));
        }
Example #4
0
        public static async Task <int> AddAsync(ossContext context, string sid, KifizetesDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.BIZONYLATMOD);

            var entity = ObjectUtils.Convert <KifizetesDto, Models.Kifizetes>(dto);

            return(await KifizetesDal.AddAsync(context, entity));
        }
Example #5
0
        public static async Task <int> AddAsync(ossContext context, string sid, IratDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.IRAT);

            var entity = ObjectUtils.Convert <IratDto, Models.Irat>(dto);

            return(await IratDal.AddAsync(context, entity));
        }
Example #6
0
        public static async Task <CsoportDto> GetAsync(ossContext context, string sid, int key)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.CSOPORT);

            var entity = await CsoportDal.GetAsync(context, key);

            return(ObjectUtils.Convert <Models.Csoport, CsoportDto>(entity));
        }
Example #7
0
        private static KifizetesDto Calc(Models.Kifizetes entity)
        {
            var result = ObjectUtils.Convert <Models.Kifizetes, KifizetesDto>(entity);

            result.Penznem     = entity.PenznemkodNavigation.Penznem1;
            result.Fizetesimod = entity.FizetesimodkodNavigation.Fizetesimod1;

            return(result);
        }
Example #8
0
        public static async Task <List <TevekenysegDto> > ReadAsync(ossContext context, string sid, string maszk)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PRIMITIVEK);

            var entities = await TevekenysegDal.ReadAsync(context, maszk);

            return(ObjectUtils.Convert <Models.Tevekenyseg, TevekenysegDto>(entities));
        }
Example #9
0
        public static async Task <FelhasznaloDto> GetAsync(ossContext context, string sid, int key)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.FELHASZNALO);

            var entity = await FelhasznaloDal.GetAsync(context, key);

            return(ObjectUtils.Convert <Models.Felhasznalo, FelhasznaloDto>(entity));
        }
        public static async Task <List <ProjektKapcsolatDto> > SelectByBizonylatAsync(ossContext context, string sid,
                                                                                      int bizonylatKod)
        {
            SessionBll.Check(context, sid);

            var entites = await ProjektKapcsolatDal.ReadByBizonylatKodAsync(context, bizonylatKod);

            return(ObjectUtils.Convert <Projektkapcsolat, ProjektKapcsolatDto>(entites));
        }
Example #11
0
        public static async Task <int> AddAsync(ossContext context, string sid, AjanlatkeresDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.AJANLATKERESMOD);

            var entity = ObjectUtils.Convert <AjanlatkeresDto, Models.Ajanlatkeres>(dto);

            return(await AjanlatkeresDal.AddAsync(context, entity));
        }
Example #12
0
        public static async Task <int> AddAsync(ossContext context, string sid, SzamlazasiRendDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PROJEKT);

            var entity = ObjectUtils.Convert <SzamlazasiRendDto, Szamlazasirend>(dto);

            return(await SzamlazasiRendDal.AddAsync(context, entity));
        }
Example #13
0
        public static async Task <TevekenysegDto> GetAsync(ossContext context, string sid, int key)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PRIMITIVEK);

            var entity = await TevekenysegDal.GetAsync(context, key);

            return(ObjectUtils.Convert <Models.Tevekenyseg, TevekenysegDto>(entity));
        }
Example #14
0
        public static async Task WebesAjanlatkeresAsync(ossContext context, IHubContext <OssHub> hubcontext,
                                                        IConfiguration config, WebesAjanlatkeresParam par)
        {
            var sid = "";

            sid = await LogonBll.BejelentkezesAsync(context, hubcontext,
                                                    config.GetValue <string>("Webesajanlatkeres:user"),
                                                    Crypt.MD5Hash(config.GetValue <string>("Webesajanlatkeres:password")), "", "", "");

            var csoport = (await LogonBll.SzerepkorokAsync(context, sid))
                          .Where(s => s.Particiokod == par.Particiokod).ToList();

            if (csoport.Count != 1)
            {
                throw new Exception("Konfigurációs hiba 1!");
            }

            await LogonBll.SzerepkorValasztasAsync(context, sid,
                                                   csoport[0].Particiokod, csoport[0].Csoportkod);

            var particioDto = await ParticioDal.GetAsync(context);

            var ec = JsonConvert.DeserializeObject <List <EmailConf> >(particioDto.Emails)
                     .Where(s => s.ConfName == config.GetValue <string>("Webesajanlatkeres:emailconf")).First();

            var dto = new AjanlatkeresDto
            {
                Particiokod              = par.Particiokod,
                Ugynoknev                = par.Ugynoknev,
                Nev                      = par.Nev,
                Cim                      = par.Cim,
                Email                    = par.Email,
                Telefonszam              = par.Telefon,
                Havifogyasztaskwh        = par.Havifogyasztaskwh,
                Haviszamlaft             = par.Haviszamlaft,
                Napelemekteljesitmenyekw = par.Napelemekteljesitmenyekw,
                Megjegyzes               = par.Megjegyzes,
                Letrehozta               = par.Ugynoknev,
                Letrehozva               = DateTime.Now,
                Modositotta              = par.Ugynoknev,
                Modositva                = DateTime.Now,
            };

            var entity = ObjectUtils.Convert <AjanlatkeresDto, Models.Ajanlatkeres>(dto);
            var id     = await AddAsync(context, sid, dto);

            //ügyfél
            var uzenet = $"Tisztelt {par.Nev}!<br><br>A következő adatokkal kért tőlünk ajánlatot: <br><br>Cím: {par.Cim}<br>Email: {par.Email}<br>Telefonszám: {par.Telefon}<br><br>Hamarosan keresni fogjuk a részletek egyeztetése céljából!<br><br>www.gridsolar.hu";

            EmailKuldes(ec, par.Email, "Re: ajánlatkérés", uzenet);
            //sales
            uzenet = $"Hello Timi,<br><br>webes ajánlatkérés érkezett, Id: {id}.<br><br>OSS";
            EmailKuldes(ec, "*****@*****.**", "Webes ajánlatkérés", uzenet);

            await LogonBll.KijelentkezesAsync(context, sid);
        }
Example #15
0
        public static async Task <int> AddAsync(ossContext context, string sid, CikkDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.CIKK);

            var entity = ObjectUtils.Convert <CikkDto, Models.Cikk>(dto);
            await CikkDal.ExistsAsync(context, entity);

            return(await CikkDal.AddAsync(context, entity));
        }
Example #16
0
        public static async Task <int> AddAsync(ossContext context, string sid, UgyfelDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.UGYFELEKMOD);

            var entity = ObjectUtils.Convert <UgyfelDto, Models.Ugyfel>(dto);
            await UgyfelDal.ExistsAsync(context, entity);

            return(await UgyfelDal.AddAsync(context, entity));
        }
Example #17
0
        public static async Task <int> AddAsync(ossContext context, string sid, PenztarDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PENZTARMOD);

            var entity = ObjectUtils.Convert <PenztarDto, Models.Penztar>(dto);
            await PenztarDal.ExistsAsync(context, entity);

            return(await PenztarDal.AddAsync(context, entity));
        }
Example #18
0
        public static async Task <int> AddAsync(ossContext context, string sid, AfakulcsDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PRIMITIVEKMOD);

            var entity = ObjectUtils.Convert <AfakulcsDto, Models.Afakulcs>(dto);
            await AfakulcsDal.ExistsAsync(context, entity);

            return(await AfakulcsDal.AddAsync(context, entity));
        }
Example #19
0
        public static async Task <int> AddAsync(ossContext context, string sid, MennyisegiegysegDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PRIMITIVEKMOD);

            var entity = ObjectUtils.Convert <MennyisegiegysegDto, Mennyisegiegyseg>(dto);
            await MennyisegiegysegDal.ExistsAsync(context, entity);

            return(await MennyisegiegysegDal.AddAsync(context, entity));
        }
        public static async Task <int> UjBizonylatToProjektAsync(ossContext context, string sid, int projektKod,
                                                                 BizonylatDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PROJEKT);

            var entity       = ObjectUtils.Convert <BizonylatDto, Models.Bizonylat>(dto);
            var bizonylatKod = await BizonylatDal.AddAsync(context, entity);

            return(await AddBizonylatToProjektAsync(context, sid, projektKod, bizonylatKod));
        }
Example #21
0
        public static async Task <BizonylatDto> GetAsync(ossContext context, string sid, int bizonylatKod)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeBizonylatAsync(context);

            var entity = await BizonylatDal.GetAsync(context, bizonylatKod);

            var dto = ObjectUtils.Convert <Models.Bizonylat, BizonylatDto>(entity);

            return(CalcCim(dto));
        }
Example #22
0
        public static async Task <ProjektJegyzetDto> GetAsync(ossContext context, string sid, int key)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PROJEKT);

            var entity = await ProjektJegyzetDal.GetAsync(context, key);

            var result = ObjectUtils.Convert <Projektjegyzet, ProjektJegyzetDto>(entity);

            return(result);
        }
Example #23
0
        public static async Task <int> AddAsync(ossContext context, string sid, FelhasznaloDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.FELHASZNALOMOD);

            var entity = ObjectUtils.Convert <FelhasznaloDto, Models.Felhasznalo>(dto);

            entity.Jelszo = Crypt.MD5Hash("");
            await FelhasznaloDal.ExistsAsync(context, entity);

            return(await FelhasznaloDal.AddAsync(context, entity));
        }
Example #24
0
        private static ProjektDto Calc(Models.Projekt entity)
        {
            var result = ObjectUtils.Convert<Models.Projekt, ProjektDto>(entity);

            result.Penznem = entity.PenznemkodNavigation.Penznem1;
            result.Ugyfelnev = entity.UgyfelkodNavigation.Nev;
            result.Ugyfelcim = UgyfelBll.Cim(entity.UgyfelkodNavigation);
            result.Ugyfeltelefonszam = entity.UgyfelkodNavigation.Telefon;
            result.Ugyfelemail = entity.UgyfelkodNavigation.Email;

            return result;
        }
Example #25
0
        public static async Task <Tuple <List <AjanlatkeresDto>, int> > SelectAsync(ossContext context, string sid, int rekordTol,
                                                                                    int lapMeret, List <SzMT> szmt)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.AJANLATKERES);

            var qry          = AjanlatkeresDal.GetQuery(context, szmt);
            var osszesRekord = qry.Count();
            var entities     = qry.Skip(rekordTol).Take(lapMeret).ToList();

            return(new Tuple <List <AjanlatkeresDto>, int>(ObjectUtils.Convert <Models.Ajanlatkeres, AjanlatkeresDto>(entities), osszesRekord));
        }
Example #26
0
        public static async Task <SzamlazasiRendDto> GetAsync(ossContext context, string sid, int key)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PROJEKT);

            var entity = await SzamlazasiRendDal.GetAsync(context, key);

            var result = ObjectUtils.Convert <Szamlazasirend, SzamlazasiRendDto>(entity);

            result.Penznem = entity.PenznemkodNavigation.Penznem1;

            return(result);
        }
Example #27
0
        public static async Task <Tuple <List <PenztarTetelDto>, int> > SelectAsync(ossContext context, string sid, int rekordTol,
                                                                                    int lapMeret, List <SzMT> szmt)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PENZTAR);

            var qry          = PenztarTetelDal.GetQuery(context, szmt);
            var osszesRekord = await qry.CountAsync();

            var entities = await qry.Skip(rekordTol).Take(lapMeret).ToListAsync();

            return(new Tuple <List <PenztarTetelDto>, int>(ObjectUtils.Convert <Models.Penztartetel, PenztarTetelDto>(entities), osszesRekord));
        }
        private static BizonylatKapcsolatDto Calc(Models.Bizonylatkapcsolat entity)
        {
            var dto = ObjectUtils.Convert <Models.Bizonylatkapcsolat, BizonylatKapcsolatDto>(entity);

            dto.Tipus       = entity.IratkodNavigation.IrattipuskodNavigation.Irattipus1;
            dto.Azonosito   = entity.Iratkod.ToString(CultureInfo.InvariantCulture);
            dto.Keletkezett = entity.IratkodNavigation.Keletkezett;
            dto.Irany       = entity.IratkodNavigation.Irany;
            dto.Kuldo       = entity.IratkodNavigation.Kuldo;
            dto.Targy       = entity.IratkodNavigation.Targy;

            return(dto);
        }
Example #29
0
        private static IratDto Calc(Models.Irat entity)
        {
            var result = ObjectUtils.Convert <Models.Irat, IratDto>(entity);

            result.Irattipus = entity.IrattipuskodNavigation.Irattipus1;
            if (entity.UgyfelkodNavigation != null)
            {
                result.Ugyfelnev = entity.UgyfelkodNavigation.Nev;
                result.Ugyfelcim = UgyfelBll.Cim(entity.UgyfelkodNavigation);
            }

            return(result);
        }
Example #30
0
        public static async Task <int> AddAsync(ossContext context, string sid, PenztarTetelDto dto)
        {
            SessionBll.Check(context, sid);
            await CsoportDal.JogeAsync(context, JogKod.PENZTAR);

            dto.Penztarbizonylatszam =
                context.KodGen(KodNev.Penztar.ToString() + dto.Penztarkod).ToString("00000") + "/" +
                dto.Penztarkod;

            var entity = ObjectUtils.Convert <PenztarTetelDto, Models.Penztartetel>(dto);

            return(await PenztarTetelDal.AddAsync(context, entity));
        }