public async Task <List <DayDto> > GetReport(int scheduleId, string userId)
{
var schedule = await context.Schedules.Include(x => x.WorkUnits).SingleOrDefaultAsync(x => x.Id == scheduleId);
var days = new List <DayDto>();
var workUnits = schedule.WorkUnits.Where(x => x.Start >= schedule.StartOfWorkingTime && x.End <= schedule.EndOfWorkingTime).ToList();
foreach (DayOfWeek day in Enum.GetValues(typeof(DayOfWeek)))
{
var dayDto = new DayDto {
Day = day, Hours = new List <HourDto>()
};
var workUnitsForOneDay = workUnits.Where(x => x.DayOfWeek == day).ToList();
for (int i = schedule.StartOfWorkingTime.Hours; i < schedule.EndOfWorkingTime.Hours; i++)
{
var start = new TimeSpan(i, 0, 0);
var end = new TimeSpan(i + 1, 0, 0);
var hourDto = new HourDto {
Start = start, End = end
};
var workUnitsForOneHour = workUnitsForOneDay.Where(x => ((x.Start <start && x.End> start) || x.Start >= start && x.Start < end)).ToList();
hourDto.IsFullWorkTimeUnit = workUnitsForOneHour.Any(x => x.Start <= start && x.End >= end);
workUnitsForOneHour = workUnitsForOneHour.GroupBy(x => x.MemberId).Select(x => x.First()).ToList();
hourDto.QuantityOfEmployees = workUnitsForOneHour.Count;
dayDto.Hours.Add(hourDto);
}
days.Add(dayDto);
}
return(days);
}
private async Task <bool> ValidateDateTime(DayDto dto)
{
var day = await this._context.Days.FirstOrDefaultAsync(d =>
d.DateTimeOffset == dto.DateTimeOffset && d.League.Id == dto.LeagueId);
return(day == null);
}
public IActionResult CreateDay(int weekId, DayForCreationDto day)
{
var week = WeeksDataStore.Current.Weeks
.FirstOrDefault(w => w.Id == weekId);
if (week == null)
{
return(NotFound());
}
var maxDayId = WeeksDataStore.Current.Weeks
.SelectMany(w => w.Days).Max(d => d.Id);
// find highest id
var finalDay = new DayDto()
{
Id = ++maxDayId,
Date = day.Date,
WeekDay = day.WeekDay
};
// add 1 to create id
week.Days.Add(finalDay);
return(CreatedAtRoute(
"GetDay",
new { weekId, id = finalDay.Id },
finalDay));
}
public async Task <ActionResult <ResultDto> > UpdateDay(string id, [FromBody] DayDto dayDto)
{
if (id != dayDto.UUID)
{
return(BadRequest());
}
return(Ok(await _dayService.UpdateDay(dayDto, HttpContext.User.Identity.Name)));
}
public ServiceResult GetDay(string date)
{
var dateTime = DateTime.Parse(date);
var day = organizerDbContext.Days.Include(x => x.ToDoEntries).Include(x => x.Notes).Include(x => x.ScheduleEntries).Where(x => x.date == dateTime).FirstOrDefault();
if (day == null)
{
return(new ServiceResult(false));
}
else
{
var noteDtos = new List <INoteDto>();
var toDoDtos = new List <IToDoDto>();
var shceduleDtos = new List <IScheduleEntryDto>();
//could make a factory to create dto objects
foreach (var a in day.Notes)
{
noteDtos.Add(new NoteDto()
{
date = a.Day.date.ToString(),
text = a.Text
});
}
foreach (var a in day.ToDoEntries)
{
toDoDtos.Add(new ToDoDto()
{
Id = a.Id,
Date = a.Day.date.ToString(),
Text = a.Text,
IsDone = a.IsDone,
});
}
foreach (var a in day.ScheduleEntries)
{
shceduleDtos.Add(new ScheduleEntryDto()
{
Id = a.Id,
Date = a.Day.date.ToString(),
Text = a.Text,
StartTime = a.StartTime.ToShortTimeString(),
EndTime = a.EndTime.ToShortTimeString()
});
}
var dayDto = new DayDto()
{
id = day.Id,
date = day.date.ToString(),
NoteDtos = noteDtos,
ToDoDtos = toDoDtos,
ScheduleDtos = shceduleDtos
};
return(new ServiceResult(dayDto, true));
}
}
private DayDto CreateDayDto(int officeid, int year, int month, int day)
{
DayDto dd = new DayDto();
dd.OfficeID = officeid;
dd.Date = new DateTime(year, month, day);
dd.MaxCapacity = GetMaxCapacity(officeid);
dd.CurrentCapacity = GetCurrentCapacity(officeid, dd.Date);
return(dd);
}
public IActionResult CreateDay(int Id)
{
var model = new DayDto();
model.UserId = Id;
model.Date = DateTime.Now;
model.Exercises = _workoutRepository.GetExercises();
return(View(model));
}
public async Task EditAsync(DayDto dto)
{
if (!await this.ValidateDateTime(dto))
{
return;
}
var model = await this.FindSingleDayAsync(dto.Id);
dto.MapTo(model, this._context);
await this._context.SaveChangesAsync();
}
public async Task <IActionResult> Edit([FromBody] DayDto dto)
{
if (!this._userService.IsAdmin())
{
return(Forbid());
}
await this._dayService.EditAsync(dto);
return(Ok());
}
public IHttpActionResult GetScheduleForInstructor()
{
var userId = User.Identity.GetUserId();
var instructor = _context.Instructors.SingleOrDefault(s => s.AccountId == userId);
if (instructor != null)
{
var currentSemesterId = _context.AcademicSemesters.Single(s => s.CurrentSemester).Id;
var scheduleEntries = _context
.ScheduleEntries
.Include(x => x.Day)
.Include(x => x.Course)
.Include(x => x.Room.Building)
.Include(x => x.LabGroup)
.Include(x => x.Day.Schedule)
.Where(s => s.InstructorId == instructor.Id && s.Day.Schedule.AcademicSemesterId == currentSemesterId)
.ToList();
var schedule = new ScheduleDto {
Days = new List <DayDto>()
};
for (int i = 0; i < GlobalConfig.NUM_OF_DAYS; i++)
{
var day = new DayDto
{
DayNumber = (byte)i,
Periods = new List <ScheduleEntryDto>()
};
for (int j = 0; j < GlobalConfig.NUM_OF_PERIODS; j++)
{
if (scheduleEntries.Any(s => s.Period == j && s.Day.DayNumber == i))
{
var scheduleEntry = scheduleEntries.Single(s => s.Period == j && s.Day.DayNumber == i);
var scheduleEntryDto = Mapper.Map <ScheduleEntry, ScheduleEntryDto>(scheduleEntry);
day.Periods.Add(scheduleEntryDto);
}
else
{
day.Periods.Add(new ScheduleEntryDto());
}
}
schedule.Days.Add(day);
}
return(Ok(schedule));
}
return(NotFound());
}
public DayDto MapDayToDayDto(Day day)
{
var dayDto = new DayDto();
dayDto.Id = day.Id;
dayDto.Name = day.Name;
dayDto.Date = day.Date;
dayDto.Notes = day.Notes;
dayDto.Workloads = day.Workloads;
dayDto.UserId = day.UserId;
return(dayDto);
}
public IActionResult CreateMyDay(int Id)
{
if (!_utilities.IsCurrentUsersAccount(Id))
{
return(RedirectToAction("Index", "Home"));
}
var model = new DayDto();
model.UserId = Id;
model.Date = DateTime.Now;
model.Exercises = _workoutRepository.GetExercises();
return(View(model));
}
public Day MapDayDtoToDay(DayDto dayDto)
{
var day = _workoutRepository.GetDay(dayDto.Id);
day.Name = dayDto.Name;
day.Date = dayDto.Date;
day.Notes = dayDto.Notes;
if (dayDto.Workloads != null)
{
day.Workloads = dayDto.Workloads;
}
day.UserId = dayDto.UserId;
return(day);
}
public async Task <IActionResult> Create([FromBody] DayDto dto)
{
if (!this._userService.IsAdmin())
{
return(Forbid());
}
var id = await this._dayService.CreateAsync(dto);
if (id < 1)
{
return(BadRequest());
}
return(Ok(id));
}
public async Task <ResultDto> ShareDay(DayDto dayDto, string userId)
{
var sharedDay = _mapper.Map <SharedDay>(dayDto);
sharedDay.User = await _context.Users.Where(u => u.UUID == userId).FirstOrDefaultAsync();
sharedDay.Meals = _mealService.AddMeals(dayDto.AllMeals, userId);
sharedDay.UUID = Guid.NewGuid().ToString();
sharedDay.CreatedAt = DateTime.Now;
sharedDay.UpdatedAt = DateTime.Now;
_context.Add(sharedDay);
await _context.SaveChangesAsync();
return(new ResultDto(true, sharedDay.UUID));
}
public async Task <int> CreateAsync(DayDto dto)
{
if (!await this.ValidateDateTime(dto))
{
return(-1);
}
var model = dto.AsModel(this._context);
model.Id = 0;
model.DateTimeOffset = model.DateTimeOffset.AddHours(2);
await this._context.Days.AddAsync(model);
await this._context.SaveChangesAsync();
return(model.Id);
}
public IActionResult CreateDay(DayDto dayDto)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("CreateDay", "bdbusr", new { id = dayDto.UserId }));
}
var day = _utilities.CreateDayEntity(dayDto.Name, dayDto.Date, dayDto.UserId);
if (!_workoutRepository.Save() || day == null)
{
return(RedirectToAction("CreateDay", "bdbusr", new { id = dayDto.UserId }));
}
foreach (var e in dayDto.ExerciseNames)
{
if (e != "")
{
var exercise = _workoutRepository.GetExerciseByName(e);
if (exercise == null)
{
exercise = _utilities.CreateExerciseEntity(e);
if (!_workoutRepository.Save())
{
return(RedirectToAction("CreateDay", "bdbusr", new { id = dayDto.UserId }));
}
}
var dayExercise = _utilities.CreateDayExerciseEntity(day.Id, exercise.Id);
if (!_workoutRepository.Save() || dayExercise == null)
{
return(RedirectToAction("CreateDay", "bdbusr", new { id = dayDto.UserId }));
}
var workload = _utilities.CreateWorkloadEntity(day.Id, exercise.Id);
}
}
_workoutRepository.AddDayForUser(dayDto.UserId, day);
if (!_workoutRepository.Save())
{
return(RedirectToAction("CreateDay", "bdbusr", new { id = dayDto.UserId }));
}
return(RedirectToAction("ViewDay", "bdbusr", new { id = day.Id }));
}
public IActionResult EditDay(DayDto dayDto)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("EditDay", "bdbusr", new { id = dayDto.Id }));
}
var day = _utilities.MapDayDtoToDay(dayDto);
_workoutRepository.ModifyDay(day);
if (!_workoutRepository.Save())
{
return(RedirectToAction("EditDay", "bdbusr", new { id = dayDto.Id }));
}
return(RedirectToAction("ViewDay", "bdbusr", new { id = dayDto.Id }));
}
public async Task <ResultDto> AddNewDay(DayDto dayDto, string userId)
{
var day = _mapper.Map <Day>(dayDto);
day.User = await _context.Users.Where(u => u.UUID == userId).FirstOrDefaultAsync();
day.Meals = _mealService.AddMeals(dayDto.AllMeals, userId);
day.UUID = Guid.NewGuid().ToString();
day.CreatedAt = DateTime.Now;
day.UpdatedAt = DateTime.Now;
day.HasVersions = false;
day.IsLatest = true;
_context.Add(day);
await _context.SaveChangesAsync();
return(new ResultDto(true, "Day added succesfully"));
}
public async Task <ResultDto> UpdateDay(DayDto dayDto, string userId)
{
Day currentDay = await _context.Days.Where(d => d.UUID == dayDto.UUID && d.User.UUID == userId)
.Include(d => d.User)
.Include(d => d.Meals)
.FirstOrDefaultAsync();
if (currentDay == null)
{
_logger.LogDebug("Day not found with UUID: ", dayDto.UUID);
return(new ResultDto(false, "Day not found"));
}
Day newDay = _mapper.Map <Day>(dayDto);
newDay.Name = currentDay.Name;
newDay.User = currentDay.User;
newDay.CreatedAt = currentDay.CreatedAt;
newDay.Meals = _mealService.AddMeals(dayDto.AllMeals, userId);
newDay.UUID = Guid.NewGuid().ToString();
newDay.Date = currentDay.Date != null ? currentDay.Date : currentDay.CreatedAt;
newDay.UpdatedAt = DateTime.Now;
newDay.IsLatest = true;
newDay.HasVersions = true;
currentDay.Name = currentDay.Name;
currentDay.IsLatest = false;
currentDay.VersionCreated = DateTime.Now;
currentDay.UpdatedAt = DateTime.Now;
currentDay.Date = dayDto.Date == null && currentDay.Date == null ? currentDay.CreatedAt : dayDto.Date;
currentDay.LatestVersionId = newDay.UUID;
currentDay.HasVersions = true;
_context.Add(newDay);
_context.Entry(currentDay).State = EntityState.Modified;
var days = await _context.Days.Where(d => d.LatestVersionId == currentDay.UUID).ToListAsync();
days.ForEach(d => d.LatestVersionId = newDay.UUID);
await _context.SaveChangesAsync();
return(new ResultDto(true, newDay.UUID));
}
private static void FillScheduleRecords()
{
var currentDay = string.Empty;
var currentTime = string.Empty;
DayDto currentDayDto = null;
for (int i = 9; i < _rows.Length; i++)
{
var nextDay = _rows[i][0].Value.ToString();
var nextTime = _rows[i][1].Value.ToString();
if (!string.IsNullOrEmpty(nextDay))
{
currentDay = nextDay;
currentDayDto = new DayDto {
DayNumber = DayDto.GetNumberByName(currentDay), DayName = currentDay
};
}
else if (LessonTimeDto.GetNumberFromPeriod(nextTime) == 1)
{
var curDayIndex = DayDto.GetNumberByName(currentDay);
currentDay = DayDto.DayNameByNumber[curDayIndex + 1];
currentDayDto = new DayDto {
DayNumber = curDayIndex + 1, DayName = currentDay
};
}
if (!string.IsNullOrEmpty(nextTime))
{
currentTime = nextTime;
}
if (currentDay != "" && currentTime != "")
{
AppendNewScheduleRecord(currentDayDto, currentTime, _rows[i]);
}
}
}
public async Task <ActionResult <ResultDto> > ShareDay([FromBody] DayDto dayDto)
{
return(Ok(await _dayService.ShareDay(dayDto, HttpContext.User.Identity.Name)));
}
private static void AppendNewScheduleRecord(DayDto dayDto, string time, Row row)
{
try
{
string subject = row[2].Value.ToString();
TeacherDto teacher = GetTeacherData(row[3].Value.ToString());
ClassRoomDto classRoom = new ClassRoomDto {
Number = row[6].Value.ToString().Replace(" ", String.Empty)
};
var weeksString = row[5].Value.ToString();
if (string.IsNullOrEmpty(teacher.LastName))
{
teacher.LastName = "Вакансія"; // in case of null
}
var groupStr = row[4].Value.ToString(); //either number or 'lecture'
if (string.IsNullOrEmpty(subject) || subject.Length <= 2)
{
return;
}
if (string.IsNullOrEmpty(classRoom.Number) ||
string.IsNullOrEmpty(weeksString) || string.IsNullOrEmpty(groupStr))
{
throw new InvalidInputException("Некоректні дані: " + dayDto.DayName + ", " + time + " у файлі " + _currentFilePath);
}
LessonTimeDto lessonTime = new LessonTimeDto {
Number = LessonTimeDto.GetNumberFromPeriod(time)
};
string group = string.Empty;
if (groupStr.Any(char.IsDigit))
{
group = groupStr.Replace(" ", "");
}
else
{
group = string.Empty;
}
LessonTypeDto lessonType = new LessonTypeDto();
lessonType.Id = LessonTypeDto.GetIdByType(group == string.Empty ? LessonType.Лекція : LessonType.Практика);
ScheduleRecordDto scheduleRecord = new ScheduleRecordDto
{
YearOfStudying = _yearOfStudying,
LessonTime = lessonTime,
Subject = subject,
LessonType = lessonType,
Group = group,
Day = dayDto,
Specialty = _specialty,
ClassRoom = classRoom,
Teacher = teacher,
Weeks = weeksString
};
var weeksStr = row[5].Value.ToString().Replace(".", ","); //replace 6.9 to 6,9
var weeksList = Utils.Utils.ParseWeeks(weeksStr);
_weekScheduleRecords.Add(scheduleRecord, new List <int>());
foreach (var weekNumber in weeksList)
{
_weekScheduleRecords[scheduleRecord].Add(weekNumber);
}
}
catch (InvalidInputException e)
{
Logger.LogException(e);
throw e;
}
catch (Exception e)
{
Logger.LogException(e);
}
}
public List <DayDto> GetWeek([FromBody] FilterWeekAppointmentDto filter)
{
// Tengo que devolver una lista con todos los dias entre la fecha desde y la fecha hasta
// Para cada dia, tengo que partirlo en 24 horas
// Para cada hora tengo que tener una lista con todas las especialidades del usuario
// Para cada especialidad tengo que decir cuantos turnos reservados tiene en esa fecha y en ese rango de horas
var res = new List <DayDto>();
using (var dbContext = new ApplicationDbContext())
{
var userId = GetUserId();
var specialties = dbContext.Clinic_Specialties.Where(s => s.UserId == userId).ToList();
var appointments = dbContext.Clinic_Appointments
.Where(a => a.Doctor.UserId == userId)
.Where(a => !filter.DoctorId.HasValue || a.DoctorId == filter.DoctorId)
.Where(a => !filter.SubSpecialtyId.HasValue || a.Doctor.SubspecialtyId == filter.SubSpecialtyId)
.Where(a => !filter.SpecialtyId.HasValue || a.Doctor.SpecialtyId == filter.SpecialtyId)
.Where(a => filter.StartDate <= a.DateTime && a.DateTime <= filter.EndDate)
.ToList();
for (var date = filter.StartDate.Date; date <= filter.EndDate.Date; date = date.AddDays(1))
{
var day = new DayDto {
Day = date, Hours = new List <HourDto>()
};
var nextDate = date.AddDays(1);
for (var datetime = date.AddHours(7); datetime < nextDate; datetime = datetime.AddHours(1))
{
var hour = new HourDto {
Hour = datetime, AppointmentsPerSpecialty = new List <AppointmentsPerSpecialtyDto>(), TotalAppointments = 0
};
var nextHour = datetime.AddHours(1);
foreach (var specialty in specialties)
{
var count = appointments.Count(a => datetime <= a.DateTime && a.DateTime < nextHour && a.Doctor.SpecialtyId == specialty.Id);
if (count > 0)
{
hour.AppointmentsPerSpecialty.Add(new AppointmentsPerSpecialtyDto
{
SpecialtyId = specialty.Id,
SpecialtyDescription = specialty.Data.Description,
Appointments = count
});
hour.TotalAppointments += count;
}
}
day.Hours.Add(hour);
}
res.Add(day);
}
}
return(res);
}
public ServiceResult GetDays()
{
var days = organizerDbContext.Days.Include(x => x.ToDoEntries).Include(x => x.Notes).Include(x => x.ScheduleEntries);
if (days == null)
{
return(new ServiceResult(false));
}
else
{
var daysList = new List <IDayDto>();
foreach (var d in days)
{
if (isDayEmpty(d))
{
continue;
}
var noteDtos = new List <INoteDto>();
var toDoDtos = new List <IToDoDto>();
var scheduleDtos = new List <IScheduleEntryDto>();
foreach (var a in d.Notes)
{
noteDtos.Add(new NoteDto()
{
id = a.Id,
date = a.Day.date.ToString(),
text = a.Text
});
}
foreach (var a in d.ToDoEntries)
{
toDoDtos.Add(new ToDoDto()
{
Id = a.Id,
Date = a.Day.date.ToString(),
Text = a.Text,
IsDone = a.IsDone,
});
}
foreach (var a in d.ScheduleEntries)
{
scheduleDtos.Add(new ScheduleEntryDto()
{
Date = a.Day.date.ToString(),
Text = a.Text,
StartTime = a.StartTime.ToShortTimeString(),
EndTime = a.EndTime.ToShortTimeString()
});
}
var day = new DayDto()
{
id = d.Id,
date = d.date.ToString("yyyy-MM-dd"),
ToDoDtos = toDoDtos,
NoteDtos = noteDtos,
ScheduleDtos = scheduleDtos
};
daysList.Add(day);
}
if (daysList.Count == 0)
{
organizerDbContext.SaveChanges();
return(new ServiceResult(false));
}
organizerDbContext.SaveChanges();
return(new ServiceResult(daysList, true));
}
}
