Example #1
0
        public async Task <ServisaLapa> TransportlidzeklaServisaLapaAsync(int id)
        {
            var sheet = await _context.ServisaLapas.AsNoTracking()
                        .Where(s => s.TransportlidzeklaId == id && s.Apmaksata == null)
                        .Include(s => s.Uznemums)
                        .Include(s => s.Klients)
                        .Include(s => s.Transportlidzeklis)
                        .Include(s => s.Defekti)
                        .Include(s => s.RezervesDalas)
                        .Include(s => s.PaveiktieDarbi)
                        .Include(s => s.Mehaniki)
                        .FirstOrDefaultAsync();

            if (sheet == null)
            {
                var vehicle = await GetTransportlidzeklisArKlientuAsync(id);

                sheet = new ServisaLapa
                {
                    Id                  = 0,
                    Datums              = DateTime.Now,
                    KlientaId           = vehicle.KlientaId,
                    Klients             = vehicle.Klients,
                    TransportlidzeklaId = vehicle.Id,
                    Transportlidzeklis  = vehicle,
                    Defekti             = new List <Defekts>(),
                    RezervesDalas       = new List <RezervesDala>(),
                    PaveiktieDarbi      = new List <PaveiktaisDarbs>(),
                    Mehaniki            = new List <Mehanikis>()
                };
            }
            return(sheet);
        }
Example #2
0
        public async Task <int> InsertServisaLapaAsync(ServisaLapa sheet)
        {
            //javascript datumi ir UTC - pārvēršam uz LocalTime
            if (sheet.Datums.Kind == DateTimeKind.Utc)
            {
                sheet.Datums = sheet.Datums.ToLocalTime();
            }
            if (sheet.Apmaksata.HasValue && sheet.Apmaksata.Value.Kind == DateTimeKind.Utc)
            {
                sheet.Apmaksata = sheet.Apmaksata.Value.ToLocalTime();
            }

            var newSheet = new ServisaLapa
            {
                Datums              = sheet.Datums,
                Apmaksata           = sheet.Apmaksata,
                UznemumaId          = sheet.UznemumaId,
                TransportlidzeklaId = sheet.TransportlidzeklaId,
                KlientaId           = sheet.KlientaId,
                Defekti             = sheet.Defekti,
                RezervesDalas       = sheet.RezervesDalas,
                PaveiktieDarbi      = sheet.PaveiktieDarbi,
                Mehaniki            = sheet.Mehaniki,
                KopejaSumma         = sheet.KopejaSumma
            };

            await _context.ServisaLapas.AddAsync(newSheet);

            await _context.SaveChangesAsync();

            return(newSheet.Id);
        }
        public async Task <IActionResult> InsertSheet([FromBody] ServisaLapa sheet)
        {
            if (sheet.Mehaniki.Count == 0)
            {
                return(StatusCode(400, new { messages = new List <string> {
                                                 "Nav norādīti Mehāniķi"
                                             } }));
            }

            var result = await _repository.InsertServisaLapaAsync(sheet);

            return(StatusCode(200, new { id = result.ToString(), message = "Izveidota jauna servisa lapa" }));
        }
        public async Task <IActionResult> UpdateSheet([FromBody] ServisaLapa sheet)
        {
            if (sheet.Id == 0)
            {
                return(StatusCode(400, new { messages = new List <string> {
                                                 "Nepareizs servisa lapas identifikators"
                                             } }));
            }
            if (sheet.Mehaniki.Count == 0)
            {
                return(StatusCode(400, new { messages = new List <string> {
                                                 "Nav norādīti Mehāniķi"
                                             } }));
            }

            var result = await _repository.UpdateServisaLapaAsync(sheet);

            if (result > 0)
            {
                return(StatusCode(200, new { message = "Servisa lapas dati atjaunināti" }));
            }
            return(StatusCode(200, new { message = "Nav izmaiņu ko saglabāt" }));
        }
Example #5
0
        public async Task <int> UpdateServisaLapaAsync(ServisaLapa sheet)
        {
            var servisaLapa = await _context.ServisaLapas
                              .Where(s => s.Id == sheet.Id)
                              .Include(s => s.Defekti)
                              .Include(s => s.RezervesDalas)
                              .Include(s => s.PaveiktieDarbi)
                              .Include(s => s.Mehaniki)
                              .FirstOrDefaultAsync();

            if (servisaLapa == null)
            {
                throw new BadRequestException($"Servisa lapa ar id={sheet.Id} netika atrasta");
            }

            var result = 0;

            #region Defekti

            var defToBeRemoved = (from d in servisaLapa.Defekti where !sheet.Defekti.Any(s => s.Id > 0 && s.Id == d.Id) select d).ToList();
            var defToBeAdded   = (from s in sheet.Defekti where !servisaLapa.Defekti.Any(d => s.Id == d.Id) select s).ToList();

            if (defToBeRemoved.Count > 0) // izdzēšam noņemtos defektus
            {
                foreach (var d in defToBeRemoved)
                {
                    servisaLapa.Defekti.Remove(d);
                }
            }

            if (defToBeAdded.Count > 0) // pievienojam jaunos
            {
                foreach (var d in defToBeAdded)
                {
                    servisaLapa.Defekti.Add(new Defekts
                    {
                        Veids     = d.Veids,
                        Nosaukums = d.Nosaukums
                    });
                }
            }

            // lai atjauninātu izmaiņas esošajos defektos
            result = await _context.SaveChangesAsync();

            foreach (var def in servisaLapa.Defekti)
            {
                var nd = sheet.Defekti.Where(d => d.Id == def.Id).FirstOrDefault();
                if (nd != null)
                {
                    def.Nosaukums = nd.Nosaukums;
                }
            }

            #endregion

            #region Paveiktais darbs

            var jobToBeRemoved = (from d in servisaLapa.PaveiktieDarbi where !sheet.PaveiktieDarbi.Any(s => s.Id > 0 && s.Id == d.Id) select d).ToList();
            var jobToBeAdded   = (from s in sheet.PaveiktieDarbi where !servisaLapa.PaveiktieDarbi.Any(d => s.Id == d.Id) select s).ToList();

            if (jobToBeRemoved.Count > 0) // izdzēšam noņemtos darbus
            {
                foreach (var j in jobToBeRemoved)
                {
                    servisaLapa.PaveiktieDarbi.Remove(j);
                }
            }

            if (jobToBeAdded.Count > 0) // pievienojam jaunos
            {
                foreach (var j in jobToBeAdded)
                {
                    servisaLapa.PaveiktieDarbi.Add(new PaveiktaisDarbs
                    {
                        Nosaukums  = j.Nosaukums,
                        Skaits     = j.Skaits,
                        Mervieniba = j.Mervieniba,
                        Cena       = j.Cena
                    });
                }
            }

            // lai atjauninātu izmaiņas esošajos darbos
            result += await _context.SaveChangesAsync();

            foreach (var job in servisaLapa.PaveiktieDarbi)
            {
                var nj = sheet.PaveiktieDarbi.Where(d => d.Id == job.Id).FirstOrDefault();
                if (nj != null)
                {
                    job.Nosaukums  = nj.Nosaukums;
                    job.Skaits     = nj.Skaits;
                    job.Mervieniba = nj.Mervieniba;
                    job.Cena       = nj.Cena;
                }
            }

            #endregion

            #region Rezerves daļas

            var partsToBeRemoved = (from d in servisaLapa.RezervesDalas where !sheet.RezervesDalas.Any(s => s.Id > 0 && s.Id == d.Id) select d).ToList();
            var partsToBeAdded   = (from s in sheet.RezervesDalas where !servisaLapa.RezervesDalas.Any(d => s.Id == d.Id) select s).ToList();

            if (partsToBeRemoved.Count > 0) // izdzēšam noņemtās rezerves daļas
            {
                foreach (var p in partsToBeRemoved)
                {
                    servisaLapa.RezervesDalas.Remove(p);
                }
            }

            if (partsToBeAdded.Count > 0) // pievienojam jaunās
            {
                foreach (var p in partsToBeAdded)
                {
                    servisaLapa.RezervesDalas.Add(new RezervesDala
                    {
                        Nosaukums  = p.Nosaukums,
                        Skaits     = p.Skaits,
                        Mervieniba = p.Mervieniba,
                        Cena       = p.Cena
                    });
                }
            }

            // lai atjauninātu izmaiņas esošajās rezerves daļās
            result += await _context.SaveChangesAsync();

            foreach (var part in servisaLapa.RezervesDalas)
            {
                var np = sheet.RezervesDalas.Where(d => d.Id == part.Id).FirstOrDefault();
                if (np != null)
                {
                    part.Nosaukums  = np.Nosaukums;
                    part.Skaits     = np.Skaits;
                    part.Mervieniba = np.Mervieniba;
                    part.Cena       = np.Cena;
                }
            }

            #endregion

            #region Mehāniķi

            var mehToBeRemoved = (from m in servisaLapa.Mehaniki where !sheet.Mehaniki.Any(s => s.Id == m.Id) select m).ToList();
            var mehToBeAdded   = (from s in sheet.Mehaniki where !servisaLapa.Mehaniki.Any(d => s.Id == d.Id) select s).ToList();

            if (mehToBeRemoved.Count > 0) // izdzēšam noņemtos mehāniķus
            {
                foreach (var m in mehToBeRemoved)
                {
                    servisaLapa.Mehaniki.Remove(m);
                }
            }

            if (mehToBeAdded.Count > 0) // pievienojam jaunos
            {
                foreach (var m in mehToBeAdded)
                {
                    servisaLapa.Mehaniki.Add(new Mehanikis
                    {
                        Id        = m.Id,
                        Nosaukums = m.Nosaukums
                    });
                }
            }

            #endregion

            //javascript datumi ir UTC - pārvēršam uz LocalTime
            if (sheet.Datums.Kind == DateTimeKind.Utc)
            {
                servisaLapa.Datums = sheet.Datums.ToLocalTime();
            }
            else
            {
                servisaLapa.Datums = sheet.Datums;
            }

            if (sheet.Apmaksata != servisaLapa.Apmaksata)
            {
                _memoryCache.Remove("TODAY-STATUS");
            }

            if (sheet.Apmaksata.HasValue && sheet.Apmaksata.Value.Kind == DateTimeKind.Utc)
            {
                servisaLapa.Apmaksata = sheet.Apmaksata.Value.ToLocalTime();
            }
            else
            {
                servisaLapa.Apmaksata = sheet.Apmaksata;
            }

            servisaLapa.UznemumaId  = sheet.UznemumaId;
            servisaLapa.Piezimes    = sheet.Piezimes;
            servisaLapa.KopejaSumma = sheet.KopejaSumma;

            result += await _context.SaveChangesAsync();

            return(result);
        }