public async Task<IActionResult> PostSession([FromBody] SessionPostOrPutDTO sessionDTO)
{
var person = await _personRepo.Find(x => x.Id == sessionDTO.PersonId);
if (person.PersonType == PersonType.Teacher)
{
var sessionTeacher = _mapper.Map<Session>(sessionDTO);
await _sessionRepo.Create(sessionTeacher);
return Created($"sessions/{sessionTeacher.Id}", sessionTeacher);
}
if (sessionDTO.SelectedClasses.Count < 1)
{
throw new TCSException("Must select at least one class.");
}
if (sessionDTO.SelectedReasons.Count < 1 && !sessionDTO.Tutoring)
{
throw new TCSException("Must select at least one reason for visit.");
}
var session = _mapper.Map<Session>(sessionDTO);
session.SessionClasses = sessionDTO.SelectedClasses.Select(x => new SessionClass() { ClassId = x }).ToList();
session.SessionReasons = sessionDTO.SelectedReasons.Select(x => new SessionReason() { ReasonId = x }).ToList();
await _sessionRepo.Create(session);
return Created($"sessions/{session.Id}", session);
}
public async Task <BannerPersonInfo> GetBannerInfo(string identifier)
{
var person = await personRepo.Find(x => x.Email == identifier || x.Id.ToString() == identifier);
if (person is Person)
{
var currentSemester = semesterRepo.GetAll().Last();
var rand = new Random(person.Id);
var takeCount = Math.Ceiling(rand.NextDouble() * 5) + 1;
var randomCourses = classRepo.GetAll().ToList().Take((int)takeCount);
if (person.PersonType == PersonType.Student)
{
return(new BannerPersonInfo()
{
EmailAddress = person.Email,
FirstName = person.FirstName,
LastName = person.LastName,
WVUPID = person.Id,
Teacher = false,
TermCode = currentSemester.Code,
Courses = randomCourses.Select(x => new BannerClass()
{
CourseName = x.Name,
CRN = x.CRN,
ShortName = x.ShortName,
Department = new BannerDepartment()
{
Code = x.Department.Code,
Name = x.Department.Name
}
})
});
}
else
{
return(new BannerPersonInfo()
{
EmailAddress = person.Email,
FirstName = person.FirstName,
LastName = person.LastName,
WVUPID = person.Id,
Teacher = true,
TermCode = currentSemester.Code,
});
}
}
throw new TCSException($"Person was not found with: {identifier}");
}
/// <summary>Returns back the student information from their WVUP Id and email</summary>
public async Task <PersonInfoDTO> GetPersonInfo(string identifier)
{
var person = await personRepo.Find(x => x.Email == identifier || x.Id.ToString() == identifier);
var bannerInfo = await bannerApi.GetBannerInfo(identifier);
var hasSchedule = await scheduleRepo.Exist(x => person is Person && x.SemesterCode == bannerInfo.TermCode && x.PersonId == person.Id);
// if person has a schedule, just return their schedule
if (person is Person && hasSchedule)
{
var schedule = scheduleRepo.GetAll(x => x.PersonId == person.Id).Select(x => x.Class);
return(new PersonInfoDTO()
{
Id = person.Id,
Email = person.Email,
FirstName = person.FirstName,
LastName = person.LastName,
PersonType = person.PersonType,
Schedule = schedule
});
}
var newPerson = new Person()
{
Email = bannerInfo.EmailAddress,
FirstName = bannerInfo.FirstName,
LastName = bannerInfo.LastName,
Id = bannerInfo.WVUPID,
PersonType = bannerInfo.Teacher ? PersonType.Teacher : PersonType.Student
};
var savedPerson = await personRepo.CreateOrUpdate(x => x.Id == newPerson.Id, newPerson);
var semester = new Semester()
{
Code = bannerInfo.TermCode
};
var savedSemester = await semesterRepo.CreateOrUpdate(x => x.Code == semester.Code, semester);
// Done if person is a teacher
if (savedPerson.PersonType == PersonType.Teacher)
{
return(new PersonInfoDTO()
{
Id = savedPerson.Id,
Email = savedPerson.Email,
FirstName = savedPerson.FirstName,
LastName = savedPerson.LastName,
PersonType = savedPerson.PersonType
});
}
var departments = bannerInfo.Courses.Select(x => x.Department).Select(x => new Department()
{
Code = x.Code,
Name = x.Name
});
foreach (var d in departments)
{
await departmentRepo.CreateOrUpdate(x => x.Code == d.Code, d);
}
var courses = bannerInfo.Courses.Select(x => new Class()
{
CRN = x.CRN,
Name = x.CourseName,
ShortName = x.ShortName,
DepartmentCode = x.Department.Code
});
foreach (var c in courses)
{
await classRepo.CreateOrUpdate(x => x.CRN == c.CRN, c);
await scheduleRepo.CreateOrUpdate(x => x.PersonId == savedPerson.Id &&
x.SemesterCode == bannerInfo.TermCode &&
x.ClassCRN == c.CRN, new Schedule()
{
SemesterCode = bannerInfo.TermCode,
PersonId = savedPerson.Id,
ClassCRN = c.CRN
});
}
return(new PersonInfoDTO()
{
Id = savedPerson.Id,
Email = savedPerson.Email,
FirstName = savedPerson.FirstName,
LastName = savedPerson.LastName,
PersonType = savedPerson.PersonType,
Schedule = courses
});
}
/// <summary>Uploads a List of CSVSessionUpload to the database</summary>
public async Task <int> UploadSessions(IEnumerable <CSVSessionUpload> sessionUploads)
{
var errorList = new List <string> ();
var personExistsErrors = (await Task.WhenAll(sessionUploads.Select(async x => {
var personExists = await personRepo.Exist(p => p.Email == x.Email);
if (!personExists)
{
return($"Person with Email: '{x.Email}' does not exist");
}
return(null);
}))).Where(x => x != null);
var classExistsErrors = (await Task.WhenAll(sessionUploads.SelectMany(x => x.CRNs).Select(async x => {
var classExists = await classRepo.Exist(c => c.CRN == x);
if (!classExists)
{
return($"Class with CRN: {x} does not exist");
}
return(null);
}))).Where(x => x != null);
var reasonExistsErrors = (await Task.WhenAll(sessionUploads.SelectMany(x => x.Reasons).Select(async x => {
var reasonExists = await reasonRepo.Exist(c => c.Name == x);
if (!reasonExists)
{
return($"Reason with Name: '{x}' does not exist");
}
return(null);
}))).Where(x => x != null);
var semesterExistError = (await Task.WhenAll(sessionUploads.Select(x => x.SemesterCode).Select(async x => {
var semesterExists = await semesterRepo.Exist(c => c.Code == x);
if (!semesterExists)
{
return($"Semester with Code: '{x}' does not exist");
}
return(null);
}))).Where(x => x != null);
errorList.AddRange(personExistsErrors);
errorList.AddRange(classExistsErrors);
errorList.AddRange(reasonExistsErrors);
errorList.AddRange(semesterExistError);
if (errorList.Count() != 0)
{
throw new TCSException(String.Join("\n", errorList));
}
var sessionList = await Task.WhenAll(sessionUploads.Select(async x => new Session()
{
Tutoring = x.Tutoring,
InTime = x.InTime,
OutTime = x.OutTime,
PersonId = (await personRepo.Find(p => p.Email == x.Email)).Id,
SemesterCode = x.SemesterCode,
SessionClasses = x.CRNs
.Select(c => new SessionClass()
{
ClassId = c
}).ToList(),
SessionReasons = await Task.WhenAll(x.Reasons
.Select(s => s.Trim())
.Select(async r => {
var reason = await reasonRepo.Find(re => re.Name == r);
return(new SessionReason()
{
ReasonId = reason.Id
});
}))
}));
return(await sessionRepo.Create(sessionList));
}
