private async Task <ShiftReport> AddShiftReport(
            PrototypeShiftReportResourceParameter parameter
            )
        {
            await using var transaction = await _context.Database
                                          .BeginTransactionAsync()
                                          .ConfigureAwait(false);

            try
            {
                var shiftDate = await GetCurrentShiftDate(parameter.Shift).ConfigureAwait(false);

                var entity = new ShiftReport
                {
                    MachineId = parameter.MachineId,
                    ShiftDate = shiftDate,
                    Shift     = parameter.Shift,
                    Timestamp = DateTime.Now
                };

                await _context.ShiftReports.AddAsync(entity).ConfigureAwait(false);

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

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

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

                throw new Exception(e.Message);
            }
        }
        public async Task <dynamic> CreateShiftReport(
            PrototypeShiftReportResourceParameter parameter
            )
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            var shiftDate = await GetCurrentShiftDate(parameter.Shift).ConfigureAwait(false);

            // get shift report record if exists
            var record = await _context.ShiftReports
                         .FirstOrDefaultAsync(
                x =>
                x.MachineId == parameter.MachineId &&
                x.ShiftDate == shiftDate &&
                x.Shift == parameter.Shift
                )
                         .ConfigureAwait(false);

            // if not add new shift report and clock number
            if (record == null)
            {
                var shiftReport = await AddShiftReport(parameter).ConfigureAwait(false);

                var clockNumber = await AddClockNumber(
                    shiftReport.ShiftReportId,
                    parameter.ClockNumber
                    )
                                  .ConfigureAwait(false);

                return(new { ShiftReport = shiftReport, ClockNumber = clockNumber });
            }

            // if record exist check if clock number exists
            var clockNumberRecord = await _context.ShiftReportClockNumbers
                                    .FirstOrDefaultAsync(
                x =>
                x.ClockNumber == parameter.ClockNumber &&
                x.ShiftReportId == record.ShiftReportId
                )
                                    .ConfigureAwait(false);

            // if exists return the record and clock number
            if (clockNumberRecord != null)
            {
                return new { ShiftReport = record, ClockNumber = clockNumberRecord }
            }
            ;

            // else add new clock number and get the shift report record
            var newClockNumber = await AddClockNumber(record.ShiftReportId, parameter.ClockNumber)
                                 .ConfigureAwait(false);

            return(new { ShiftReport = record, ClockNumber = newClockNumber });
        }
        public async Task <IActionResult> CreateShiftReport(
            PrototypeShiftReportResourceParameter parameter
            )
        {
            try
            {
                var data = await _service.CreateShiftReport(parameter).ConfigureAwait(false);

                return(Ok(data));
            }
            catch (Exception e)
            {
                return(BadRequest(e.Message));
            }
        }