public virtual async Task <EndOfShiftReport> CreateEos(EndOfShiftReport data)
        {
            if (data == null)
            {
                throw new ArgumentNullException(nameof(data));
            }
            await using var transaction = await _fmsb2Context.Database
                                          .BeginTransactionAsync()
                                          .ConfigureAwait(false);

            try
            {
                data.ShiftDate = data.ShiftDate.Date;
                await _fmsb2Context.EndOfShiftReports.AddAsync(data).ConfigureAwait(false);

                await _fmsb2Context.SaveChangesAsync().ConfigureAwait(false);

                await transaction.CommitAsync().ConfigureAwait(false);

                return(data);
            }
            catch (Exception e)
            {
                await transaction.RollbackAsync().ConfigureAwait(false);

                throw new Exception(e.Message);
            }
        }
        public async Task <IActionResult> AddClockNumbers(ClockNumberResourceParameter parameters)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException(nameof(parameters));
            }

            var clockNumbers = await _context.AuthorizeClocks.ToListAsync().ConfigureAwait(false);

            var clocks = parameters.ClockNumbers
                         .Where(
                x =>
            {
                var isExists = clockNumbers.Any(
                    e => e.Clocknum == x.Clocknum && e.MachineId == x.MachineId
                    );
                return(!isExists);
            }
                )
                         .Select(
                x =>
                new AuthorizeClocks
            {
                Clocknum     = x.Clocknum,
                MachineId    = x.MachineId,
                Modifieddate = DateTime.Now
            }
                );

            _context.AuthorizeClocks.AddRange(clocks);
            await _context.SaveChangesAsync().ConfigureAwait(false);

            return(Ok(true));
        }
        public async Task UploadAttachments(int projectTrackerId, List <IFormFile> files)
        {
            if (files.Count == 0)
            {
                return;
            }

            var attachments = new List <ProjectTrackerAttachment>();

            foreach (var file in files)
            {
                await using var target = new MemoryStream();
                await file.CopyToAsync(target).ConfigureAwait(false);

                var attachment = new ProjectTrackerAttachment
                {
                    ProjectTrackerId = projectTrackerId,
                    FileName         = file.FileName,
                    ContentType      = file.ContentType,
                    Data             = target.ToArray(),
                    Timestamp        = DateTime.Now
                };

                attachments.Add(attachment);
            }

            await _context.ProjectTrackerAttachments.AddRangeAsync(attachments).ConfigureAwait(false);

            await _context.SaveChangesAsync().ConfigureAwait(false);
        }
Exemple #4
0
        public async Task <ActionResult> DeleteComponent(int id)
        {
            try
            {
                _context.ComponentTraceability.Remove(new ComponentTraceability {
                    Id = id
                });
                await _context.SaveChangesAsync().ConfigureAwait(false);

                return(Ok(true));
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return(BadRequest(e.Message));
            }
        }
        public async Task <LogisticsInventoryCostTarget> AddOrUpdateCostTarget(
            LogisticsInventoryCostTarget data
            )
        {
            if (data == null)
            {
                throw new ArgumentNullException(nameof(data));
            }
            await using var transaction = await _fmsb2Context.Database
                                          .BeginTransactionAsync()
                                          .ConfigureAwait(false);

            try
            {
                _fmsb2Context.Update(data);
                await _fmsb2Context.SaveChangesAsync().ConfigureAwait(false);

                await transaction.CommitAsync().ConfigureAwait(false);

                return(data);
            }
            catch (Exception e)
            {
                await transaction.RollbackAsync().ConfigureAwait(false);

                throw new Exception(e.Message);
            }
        }
Exemple #6
0
        public async Task <ProjectTracker> AddOrUpdate(ProjectTracker data)
        {
            await using var transaction = await _context.Database
                                          .BeginTransactionAsync()
                                          .ConfigureAwait(false);

            try
            {
                var result = _context.ProjectTracker.Update(data);
                await _context.SaveChangesAsync().ConfigureAwait(false);

                await transaction.CommitAsync().ConfigureAwait(false);

                return(result.Entity);
            }
            catch (Exception e)
            {
                await transaction.RollbackAsync().ConfigureAwait(false);

                throw new Exception(e.Message);
            }
        }
        public async Task <IActionResult> DeleteAttachment(int id)
        {
            try
            {
                _context.ProjectTrackerAttachments
                .Remove(new ProjectTrackerAttachment {
                    ProjectTrackerAttachmentId = id
                });

                await _context.SaveChangesAsync().ConfigureAwait(false);

                return(Ok(true));
            }
            catch (Exception e)
            {
                return(BadRequest(e.Message));
            }
        }
Exemple #8
0
        public async Task <ComponentTraceability> Add(string barcode, int hourId)
        {
            var split     = barcode.Split(",");
            var lotNumber = split.LastOrDefault();
            var component = split.FirstOrDefault();

            var entity = await _context
                         .ComponentTraceability
                         .AddAsync(new ComponentTraceability
            {
                HourId        = hourId,
                Hour          = 9999,
                ComponentPart = component?.ToUpper(),
                LotNumber     = lotNumber?.ToUpper(),
                Modifiedate   = DateTime.Now
            });

            await _context.SaveChangesAsync();

            return(entity.Entity);
        }