public MeritBadgeClassViewModel(MeritBadgeClass meritBadgeClass, MeritBadgeDataHelperModel data)
{
ClassId = meritBadgeClass.ClassId;
ClassName = meritBadgeClass.ClassName;
CounselorId = meritBadgeClass.CounselorId;
Counselor = data.MeritBadgeCounselors.Where(c => CounselorId != null && c.CounselorId == CounselorId)
.Select(c => new MeritBadgeCounselorViewModel(c, data))
.SingleOrDefault();
}
public StudentClassEntryViewModel(StudentClassEntry studentClassEntry, MeritBadgeDataHelperModel data)
{
StudentId = studentClassEntry.StudentId;
ClassId = studentClassEntry.ClassId;
Complete = studentClassEntry.Complete;
Requirements = studentClassEntry.Requirements;
Remarks = studentClassEntry.Remarks;
MeritBadgeClass = data.MeritBadgeClasses.Where(c => c.ClassId == ClassId).Select(c => new MeritBadgeClassViewModel(c, data)).SingleOrDefault();
}
public MeritBadgeCounselorViewModel(MeritBadgeCounselor meritBadgeCounselor, MeritBadgeDataHelperModel data)
{
CounselorId = meritBadgeCounselor.CounselorId;
FirstName = meritBadgeCounselor.FirstName;
LastName = meritBadgeCounselor.LastName;
Address = meritBadgeCounselor.Address;
City = meritBadgeCounselor.City;
State = meritBadgeCounselor.State;
ZipCode = meritBadgeCounselor.ZipCode;
Telephone = meritBadgeCounselor.Telephone;
Email = meritBadgeCounselor.Email;
}
public MeritBadgeStudentViewModel(MeritBadgeStudent meritBadgeStudent, MeritBadgeDataHelperModel data)
{
StudentId = meritBadgeStudent.StudentId;
FirstName = meritBadgeStudent.FirstName;
LastName = meritBadgeStudent.LastName;
Address = meritBadgeStudent.Address;
City = meritBadgeStudent.City;
State = meritBadgeStudent.State;
ZipCode = meritBadgeStudent.ZipCode;
UnitType = meritBadgeStudent.UnitType;
UnitNumber = meritBadgeStudent.UnitNumber;
District = meritBadgeStudent.District;
Council = meritBadgeStudent.Council;
Email = meritBadgeStudent.Email;
StudentClassEntries = data.StudentClassEntries.Where(e => e.StudentId == StudentId).Select(e => new StudentClassEntryViewModel(e, data));
}
/// <summary>
/// Exports the blue cards
/// </summary>
/// <param name="classFile">File of classes</param>
/// <param name="counselorFile">File of counselors</param>
/// <param name="studentFile">File of students</param>
/// <param name="studentEntryFile">File of student class entries</param>
/// <param name="sortOrder">The sort order</param>
/// <param name="writeVoid">Whether to separate the downloads by unit number</param>
/// <returns>JSON to download the file through AJAX</returns>
public async Task <IActionResult> OnPost(IFormFile classFile, IFormFile counselorFile, IFormFile studentFile, IFormFile studentEntryFile, int sortOrder, bool writeVoid)
{
if (sortOrder <= 0 || 5 <= sortOrder)
{
sortOrder = 1;
}
(Data, _) = await FileUtility.ImportFile(classFile, (int)FileTypeEnum.ClassFile);
MeritBadgeClasses = Data.MeritBadgeClasses;
(Data, _) = await FileUtility.ImportFile(counselorFile, (int)FileTypeEnum.CounselorFile);
MeritBadgeCounselors = Data.MeritBadgeCounselors;
(Data, _) = await FileUtility.ImportFile(studentFile, (int)FileTypeEnum.StudentFile);
MeritBadgeStudents = Data.MeritBadgeStudents;
(Data, _) = await FileUtility.ImportFile(studentEntryFile, (int)FileTypeEnum.StudentClassEntryFile);
StudentClassEntries = Data.StudentClassEntries;
if (MeritBadgeClasses == null || MeritBadgeCounselors == null || MeritBadgeStudents == null || StudentClassEntries == null)
{
return(NotFound("Error: One or more of the import files are invalid. Please validate the files before exporting."));
}
if (sortOrder == 2)
{
MeritBadgeStudents = MeritBadgeStudents.OrderBy(s => s.FirstName).ToList();
}
else if (sortOrder == 3)
{
MeritBadgeStudents = MeritBadgeStudents.OrderBy(s => s.LastName).ToList();
}
else if (sortOrder == 4)
{
MeritBadgeStudents = MeritBadgeStudents.OrderBy(s => s.UnitNumber).ToList();
}
Data = new MeritBadgeDataHelperModel
{
MeritBadgeClasses = MeritBadgeClasses,
MeritBadgeCounselors = MeritBadgeCounselors,
MeritBadgeStudents = MeritBadgeStudents,
StudentClassEntries = StudentClassEntries,
};
var byteArrays = new List <byte[]>();
foreach (var student in MeritBadgeStudents)
{
try
{
var mbcstudent = new MeritBadgeStudentViewModel(student, Data);
if (mbcstudent.StudentClassEntries.Any())
{
var numberOfPDFs = mbcstudent.StudentClassEntries.Count() / 3;
numberOfPDFs += mbcstudent.StudentClassEntries.Count() % 3 != 0 ? 1 : 0;
for (var i = 1; i <= numberOfPDFs; i++)
{
using var outputPDFStream = BlueCardUtility.GetBlueCards(mbcstudent, i, writeVoid);
byteArrays.Add(outputPDFStream.ToArray());
}
}
}
catch (Exception e)
{
return(NotFound($"Error: Unable to export blue cards for merit badge student with StudentId = {student.StudentId}. Error Message: {e.Message}"));
}
}
var handle = Guid.NewGuid().ToString();
_cache.Set(handle, BlueCardUtility.ConcatenatePDFs(byteArrays), new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromMinutes(5)));
var outputFileName = $"BlueCards_{DateTime.Now:yyyy-MM-dd}.pdf";
var result = new JsonResult(new { FileGuid = handle, FileName = outputFileName });
return(result);
}
/// <summary>
/// Imports the file into a data structure, validates it, and displays result messages
/// </summary>
/// <param name="file">The file the user submits</param>
/// <param name="fileType">What the file is for</param>
/// <returns>A tuple of the data and result messages</returns>
public static async Task <(MeritBadgeDataHelperModel, List <string>)> ImportFile(IFormFile file, int fileType)
{
ResultMessage = new List <string>();
if (file == null || file.Length == 0)
{
ResultMessage.Add("File is empty.");
return(null, ResultMessage);
}
MeritBadgeDataHelperModel model = new MeritBadgeDataHelperModel();
using (var stream = new FileStream(Path.GetTempFileName(), FileMode.Create, FileAccess.ReadWrite, FileShare.None, 4096, FileOptions.DeleteOnClose))
{
try
{
await file.CopyToAsync(stream).ConfigureAwait(false);
stream.Position = 0;
using var reader = new CsvReader(new StreamReader(stream), CultureInfo.InvariantCulture);
switch (fileType)
{
case (int)FileTypeEnum.ClassFile:
{
var classes = reader.GetRecords <MeritBadgeClass>();
if (classes == null)
{
ResultMessage.Add("Error: Unable to validate file.");
}
else
{
model.MeritBadgeClasses = classes.ToList();
if (ValidateClassList(model.MeritBadgeClasses))
{
ResultMessage.Add($"Success! {model.MeritBadgeClasses.Count} records validated.");
}
}
break;
}
case (int)FileTypeEnum.CounselorFile:
{
var counselors = reader.GetRecords <MeritBadgeCounselor>();
if (counselors == null)
{
ResultMessage.Add("Error: Unable to validate file.");
}
else
{
model.MeritBadgeCounselors = counselors.ToList();
if (ValidateCounselorList(model.MeritBadgeCounselors))
{
ResultMessage.Add($"Success! {model.MeritBadgeCounselors.Count} records validated.");
}
}
break;
}
case (int)FileTypeEnum.StudentFile:
{
var students = reader.GetRecords <MeritBadgeStudent>();
if (students == null)
{
ResultMessage.Add("Error: Unable to validate file.");
}
else
{
model.MeritBadgeStudents = students.ToList();
if (ValidateStudentList(model.MeritBadgeStudents))
{
ResultMessage.Add($"Success! {model.MeritBadgeStudents.Count} records validated.");
}
}
break;
}
case (int)FileTypeEnum.StudentClassEntryFile:
{
var studentClassEntries = reader.GetRecords <StudentClassEntry>();
if (studentClassEntries == null)
{
ResultMessage.Add("Error: Unable to validate file.");
}
else
{
var studentClassEntryList = studentClassEntries.ToList();
model.StudentClassEntries = studentClassEntryList;
if (ValidateStudentClassEntryList(model.StudentClassEntries))
{
ResultMessage.Add($"Success! {model.StudentClassEntries.Count} records validated.");
}
}
break;
}
default:
ResultMessage.Add("Error: Invalid file type passed in.");
break;
}
}
catch (Exception e)
{
ResultMessage.Add("Error: Unable to validate file.");
ResultMessage.Add(e.Message);
}
}
return(model, ResultMessage);
}
