public async Task <ResultModel <AppointmentCalendarOutputModel> > UpdateAppointmentCalendar(AppointmentCalendarInputModel item)
        {
            var appointmentCalendarModel = new AppointmentCalendarModel()
            {
                AppointmentDate = item.AppointmentDate,
                PatientId       = item.PatientId,
                PersonnelId     = item.PersonnelId
            };

            return(await _appointmentCalendarStoreService.UpdateAndSaveAsync <AppointmentCalendarOutputModel>(appointmentCalendarModel));
        }
        public async Task <ResultModel <AppointmentCalendarOutputModel> > InsertAppointmentCalendar([FromBody] AppointmentCalendarInputModel item)
        {
            var result = new ResultModel <AppointmentCalendarOutputModel> {
                Info = new Info {
                    Succeeded = false
                }
            };

            await semaphoreSlim.WaitAsync(TimeSpan.FromSeconds(5));

            try
            {
                var systemSettings = await _settingStoreService.GetAllAsync();

                var appointmentDateTime = new DateTime(item.AppointmentDate.Year, item.AppointmentDate.Month, item.AppointmentDate.Day, Convert.ToInt32(item.AppointmentTime.Split(':')[0]), Convert.ToInt32(item.AppointmentTime.Split(':')[1]), 0);

                var intervalStartMinuteDifference = 0;
                var minutesFromStart = (appointmentDateTime - new DateTime(appointmentDateTime.Year, appointmentDateTime.Month, appointmentDateTime.Day, start.Hour, start.Minute, 0)).TotalMinutes;

                var roundingIntervalValue = systemSettings.SingleOrDefault(x => x.Key == SettingKey.RoundingIntervalValue.ToString()).IntValue.Value;
                //Eğer başlangıç dakikası, her randevuya ayrılacak sürenin bir katı değilse
                if (start.Minute > 0 && start.Minute % roundingIntervalValue > 0)
                {
                    intervalStartMinuteDifference += roundingIntervalValue - start.Minute % roundingIntervalValue;
                }

                var appointmentAvailable = await CheckAppointmentAsync(item.PersonnelId, appointmentDateTime, availableAppointmentTimes.Count(x => x == minutesFromStart - intervalStartMinuteDifference));

                if (!appointmentAvailable)
                {
                    result.Info.Message = MessageType.AppointmentIsNotAvailable;
                    return(result);
                }

                var patientItem = new PatientModel()
                {
                    IdentityNumber = item.IdentityNumber,
                    FirstName      = item.FirstName,
                    LastName       = item.LastName,
                    Phone          = item.Phone,
                    Address        = item.Address
                };

                var patient = await _patientStoreService.InsertAndSaveAsync <PatientOutputModel>(patientItem);

                if (patient.Info.Succeeded)
                {
                    var appointmentCalendarItem = new AppointmentCalendarModel()
                    {
                        AppointmentDate = appointmentDateTime,
                        PatientId       = patient.Result.Id,
                        PersonnelId     = item.PersonnelId
                    };

                    result = await _appointmentCalendarStoreService.InsertAndSaveAsync <AppointmentCalendarOutputModel>(appointmentCalendarItem);
                }
            }
            finally
            {
                semaphoreSlim.Release();
            }

            return(result);
        }