public PetitionController(IEmailService emailService, ICeremonyService ceremonyService, IPetitionService petitionService, IErrorService errorService)
{
_emailService = emailService;
_ceremonyService = ceremonyService;
_petitionService = petitionService;
_errorService = errorService;
}
public static AdminExtraTicketPetitionViewModel Create(IRepository repository, ICeremonyService ceremonyService, IPetitionService petitionService, IPrincipal currentUser, TermCode termCode, int? ceremonyId, bool? viewAll)
{
Check.Require(repository != null, "Repository is required.");
// set the default to false
viewAll = viewAll ?? false;
var ceremonies = ceremonyService.GetCeremonies(currentUser.Identity.Name, termCode);
//var ceremonyIds = ceremonies.Select(a => a.Id).ToList();
var viewModel = new AdminExtraTicketPetitionViewModel()
{
Ceremonies = ceremonies,
Ceremony = ceremonyId.HasValue ? repository.OfType<Ceremony>().GetNullableById(ceremonyId.Value) : null,
ViewAll = viewAll.Value
};
// has a ceremony been selected and does the current user have access
if (ceremonyId.HasValue && ceremonyService.HasAccess(ceremonyId.Value, currentUser.Identity.Name))
{
if (viewAll.Value)
{
viewModel.RegistrationParticipations = viewModel.Ceremony.RegistrationParticipations.Where(a => a.ExtraTicketPetition != null).ToList();
}
else
{
viewModel.RegistrationParticipations = petitionService.GetPendingExtraTicket(currentUser.Identity.Name, ceremonyId.Value, termCode);
}
}
return viewModel;
}
public static AdminRegistrationViewModel Create(IRepository repository, IMajorService majorService, ICeremonyService ceremonyService, IRegistrationService registrationService, TermCode termCode, string userId, string studentid, string lastName, string firstName, string majorCode, int? ceremonyId, string collegeCode)
{
Check.Require(repository != null, "Repository is required.");
Check.Require(majorService != null, "Major service is required.");
Check.Require(ceremonyService != null, "ceremonyService is required.");
var ceremonies = ceremonyService.GetCeremonies(userId, termCode);
var colleges = new List<College>();
foreach(var a in ceremonies) colleges.AddRange(a.Colleges);
var viewModel = new AdminRegistrationViewModel()
{
MajorCodes = majorService.GetByCeremonies(userId, ceremonies),
Colleges = colleges.Distinct().ToList(),
Ceremonies = ceremonies,
studentidFilter = studentid,
lastNameFilter = lastName,
firstNameFilter = firstName,
majorCodeFilter = majorCode,
ceremonyFilter = ceremonyId ?? -1,
collegeFilter = collegeCode,
Participations = registrationService.GetFilteredParticipationList(userId, studentid, lastName, firstName, majorCode, ceremonyId, collegeCode, ceremonies, termCode)
};
//if (!string.IsNullOrEmpty(majorCode))
// viewModel1111 = viewModel.Registrations.Where(a => a.Student.StrMajorCodes.Contains(majorCode));
return viewModel;
}
public EmailQueueController(IRepository<EmailQueue> emailQueueRepository, IRepositoryWithTypedId<Student, Guid> studentRepository , ICeremonyService ceremonyService, ILetterGenerator letterGenerator)
{
_emailQueueRepository = emailQueueRepository;
_studentRepository = studentRepository;
_ceremonyService = ceremonyService;
_letterGenerator = letterGenerator;
}
public PetitionService(IRepository<Registration> registrationRepository, IRepository<RegistrationParticipation> registrationParticipationRepository, IRepository<ExtraTicketPetition> extraTicketRepository, IRepository<RegistrationPetition> registrationPetitionRepository, ICeremonyService ceremonyService)
{
_registrationRepository = registrationRepository;
_registrationParticipationRepository = registrationParticipationRepository;
_extraTicketRepository = extraTicketRepository;
_registrationPetitionRepository = registrationPetitionRepository;
_ceremonyService = ceremonyService;
}
public CeremonyController(IRepositoryWithTypedId<TermCode, string> termRepository, IRepositoryWithTypedId<vTermCode, string> vTermRepository, IRepositoryWithTypedId<College, string> collegeRepository, IMajorService majorService, ICeremonyService ceremonyService, IUserService userService)
{
_termRepository = termRepository;
_vTermRepository = vTermRepository;
_collegeRepository = collegeRepository;
_majorService = majorService;
_ceremonyService = ceremonyService;
_userService = userService;
}
public static AdminStudentViewModel Create(IRepository repository, IMajorService majorService, ICeremonyService ceremonyService, TermCode termCode, string studentid, string lastName, string firstName, string majorCode, string college, string userId)
{
Check.Require(repository != null, "Repository is required.");
// build a list of majors that the current user has assigned to their ceremonies
var ceremonies = ceremonyService.GetCeremonies(userId, TermService.GetCurrent());
var majors = ceremonies.SelectMany(a => a.Majors).Where(a => a.ConsolidationMajor == null && a.IsActive).ToList();
var colleges = ceremonies.SelectMany(a => a.Colleges).Distinct().ToList();
var viewModel = new AdminStudentViewModel()
{
MajorCodes = majors,
studentidFilter = studentid,
lastNameFilter = lastName,
firstNameFilter = firstName,
majorCodeFilter = majorCode,
Colleges = colleges
};
var query = repository.OfType<Student>().Queryable.Where(a =>
a.TermCode == termCode
&& (a.StudentId.Contains(string.IsNullOrEmpty(studentid) ? string.Empty : studentid.Trim()))
&& (a.LastName.Contains(string.IsNullOrEmpty(lastName) ? string.Empty : lastName.Trim()))
&& (a.FirstName.Contains(string.IsNullOrEmpty(firstName) ? string.Empty : firstName.Trim()))
);
// get the list of students with optional filters
var students = query.ToList();
if (colleges.Count == 1)
{
var coll = colleges.First();
students = students.Where(a => a.StrColleges.Contains(coll.Id)).ToList();
}
if (!string.IsNullOrEmpty(majorCode)) students = students.Where(a => a.StrMajorCodes.Contains(majorCode)).ToList();
if (!string.IsNullOrEmpty(college)) students = students.Where(a => a.StrColleges.Contains(college)).ToList();
// get all active registrations
var reg = repository.OfType<RegistrationParticipation>().Queryable.Where(
a => a.Ceremony.TermCode == termCode).// && !a.Registration.Student.SjaBlock && !a.Registration.Cancelled).
ToList();
var regStudents = reg.Select(a => a.Registration.Student);
viewModel.StudentRegistrationModels = new List<StudentRegistrationModel>();
foreach(var s in students.Distinct().ToList())
{
var reged = regStudents.Any(a => a == s);
viewModel.StudentRegistrationModels.Add(new StudentRegistrationModel(s, reged));
}
return viewModel;
}
public static CommencementViewModel Create(IRepository repository, ICeremonyService ceremonyService, string userId)
{
Check.Require(repository != null, "Repository is required.");
Check.Require(!string.IsNullOrEmpty(userId), "User Id is required.");
var viewModel = new CommencementViewModel()
{
Ceremonies = ceremonyService.GetCeremonies(userId)
};
return viewModel;
}
public static EmailStudentsViewModel Create(IRepository repository, ICeremonyService ceremonyService, string userId, List<string> templateNames )
{
Check.Require(repository != null, "Repository is required.");
var viewModel = new EmailStudentsViewModel()
{
Ceremonies = ceremonyService.GetCeremonies(userId, TermService.GetCurrent()),
TemplateTypes = repository.OfType<TemplateType>().Queryable.Where(a => templateNames.Contains(a.Name)).ToList()
};
return viewModel;
}
public static AdminEditStudentViewModel Create(IRepository repository, ICeremonyService ceremonyService, Student student, string userId)
{
Check.Require(repository != null, "Repository is required.");
var viewModel = new AdminEditStudentViewModel()
{
Student = student,
Majors = repository.OfType<MajorCode>().Queryable.Where(a => a.IsActive).OrderBy(a => a.Name).ToList(),
Ceremonies = ceremonyService.GetCeremonies(userId, TermService.GetCurrent())
};
return viewModel;
}
public AdminController(IRepositoryWithTypedId<Student, Guid> studentRepository, IRepositoryWithTypedId<MajorCode, string> majorRepository, IStudentService studentService, IEmailService emailService, IMajorService majorService, ICeremonyService ceremonyService, IRegistrationService registrationService, IRegistrationPopulator registrationPopulator, IRepository<Registration> registrationRepository, IErrorService errorService, IReportService reportService)
{
if (emailService == null) throw new ArgumentNullException("emailService");
_studentRepository = studentRepository;
_majorRepository = majorRepository;
_studentService = studentService;
_emailService = emailService;
_majorService = majorService;
_ceremonyService = ceremonyService;
_registrationService = registrationService;
_registrationPopulator = registrationPopulator;
_registrationRepository = registrationRepository;
_errorService = errorService;
_reportService = reportService;
}
public static MoveMajorViewModel Create(IRepository repository, IPrincipal currentUser, ICeremonyService ceremonyService)
{
Check.Require(repository != null, "Repository is required.");
var viewModel = new MoveMajorViewModel() {Ceremonies = ceremonyService.GetCeremonies(currentUser.Identity.Name, TermService.GetCurrent()), MajorCodes = new List<MajorCode>()};
//viewModel.MajorCodes = viewModel.Ceremonies.Select(a => a.Majors).ToList();
var majorCodes = new List<MajorCode>();
foreach (var a in viewModel.Ceremonies)
{
majorCodes.AddRange(a.Majors);
}
viewModel.MajorCodes = majorCodes.OrderBy(a=>a.Name).Distinct().ToList();
return viewModel;
}
public static ReportViewModel Create(IRepository repository, ICeremonyService ceremonyService, string userId)
{
Check.Require(repository != null, "Repository is required.");
var ceremonies = ceremonyService.GetCeremonies(userId);
var terms = ceremonies.Select(a => a.TermCode).OrderByDescending(a => a.Id).Distinct();
var existingTerms = repository.OfType<TermCode>().Queryable.Select(a=>a.Id).ToList();
var viewModel = new ReportViewModel()
{
TermCodes = terms,
TermCode = terms.First(),
};
return viewModel;
}
public static AdminMajorsViewModel Create(IRepository repository, ICeremonyService ceremonyService, IRegistrationService registrationService, IPrincipal user)
{
Check.Require(repository != null, "Repository is required.");
Check.Require(ceremonyService != null, "ceremonyService is required.");
Check.Require(user != null, "user is required.");
// get the current user's ceremonies
var ceremonies = ceremonyService.GetCeremonies(user.Identity.Name, TermService.GetCurrent());
var participations = repository.OfType<RegistrationParticipation>().Queryable.Where(a => ceremonies.Contains(a.Ceremony)).ToList();
participations = participations.Where(a => a.IsValidForTickets).ToList();
var viewModel = new AdminMajorsViewModel() {CeremonyCounts = new List<CeremonyCounts>()};
// go through all the ceremonies
foreach (var a in ceremonies)
{
var ceremonyCount = new CeremonyCounts() {Ceremony = a, MajorCounts = new List<MajorCount>()};
// go through each of the majors
foreach (var b in a.Majors)
{
var majorCount = new MajorCount() {Major = b};
majorCount.TotalTickets = participations.Where(c => c.Major == b).Sum(c => c.TotalTickets);
majorCount.TotalStreaming = participations.Where(c => c.Major == b).Sum(c => c.TotalStreamingTickets);
majorCount.ProjectedTickets = participations.Where(c => c.Major == b).Sum(c => c.ProjectedTickets);
majorCount.ProjectedStreamingTickets = participations.Where(c => c.Major == b).Sum(c => c.ProjectedStreamingTickets);
if (majorCount.TotalTickets > 0 || majorCount.TotalStreaming > 0 || majorCount.ProjectedTickets > 0 || majorCount.ProjectedStreamingTickets > 0)
{
ceremonyCount.MajorCounts.Add(majorCount);
}
}
viewModel.CeremonyCounts.Add(ceremonyCount);
}
return viewModel;
}
public StudentController(IStudentService studentService,
IEmailService emailService,
IRepositoryWithTypedId<Student, Guid> studentRepository,
IRepository<Ceremony> ceremonyRepository,
IRepository<Registration> registrationRepository,
IErrorService errorService,
ICeremonyService ceremonyService,
IReportService reportService,
IRepository<RegistrationPetition> registrationPetitionRepository,
IRepository<RegistrationParticipation> participationRepository, IRegistrationPopulator registrationPopulator)
{
_studentRepository = studentRepository;
_ceremonyRepository = ceremonyRepository;
_registrationRepository = registrationRepository;
_errorService = errorService;
_ceremonyService = ceremonyService;
_reportService = reportService;
_registrationPetitionRepository = registrationPetitionRepository;
_participationRepository = participationRepository;
_registrationPopulator = registrationPopulator;
_studentService = studentService;
_emailService = emailService;
}
public static AdminPetitionsViewModel Create(IRepository repository, ICeremonyService ceremonyService, IPetitionService petitionService, string userId, TermCode termCode)
{
Check.Require(repository!= null, "Repository is required.");
//var viewModel = new AdminPetitionsViewModel()
// {
// PendingExtraTicket = repository.OfType<Registration>().Queryable.Where(a => a.ExtraTicketPetition != null && a.ExtraTicketPetition.IsPending).ToList(),
// Ceremonies = repository.OfType<Ceremony>().Queryable.Where(a=>a.TermCode == TermService.GetCurrent()),
// PendingRegistrationPetitions = repository.OfType<RegistrationPetition>().Queryable.Where(
// a=>a.TermCode == TermService.GetCurrent() && a.IsPending).ToList()
// };
var ceremonies = ceremonyService.GetCeremonies(userId, termCode);
var ceremonyIds = ceremonies.Select(a => a.Id).ToList();
var viewModel = new AdminPetitionsViewModel()
{
//PendingExtraTicket = petitionService.GetPendingExtraTicket(userId, termCode, ceremonyIds),
PendingRegistrationPetitions = petitionService.GetPendingRegistration(userId, termCode, ceremonyIds),
Ceremonies = ceremonies
};
return viewModel;
}
public MajorService(IRepositoryWithTypedId<MajorCode, string> majorRepository, ICeremonyService ceremonyService)
{
_majorRepository = majorRepository;
_ceremonyService = ceremonyService;
}
public static RegistrationDataViewModel Create(IRepository repository, ICeremonyService ceremonyService, string userId, TermCode termCode)
{
Check.Require(repository != null, "Repository is required.");
//var viewModel = new RegistrationDataViewModel();
//viewModel.RegistrationData = new List<RegistrationData>();
//var ceremonies = ceremonyService.GetCeremonies(userId, termCode);
//viewModel.RegistrationData = ceremonies.Select(a => new RegistrationData()
// {
// TermCode = a.TermCode,
// Ceremony = a,
// Registrants = a.RegistrationParticipations.Count(),
// CancelledRegistrants = a.RegistrationParticipations.Count(),
// RegistrationPetitionsSubmitted = a.RegistrationPetitions.Count,
// RegistrationPetitionsApproved =
// a.RegistrationPetitions.Where(
// b => b.IsApproved && !b.IsPending).Count(),
// TicketsRequested = a.ProjectedTicketCount,
// ExtraTicketsRequested = a.ProjectedTicketCount,
// TotalTickets = a.TotalTickets
// }).ToList();
//return viewModel;
var viewModel = new RegistrationDataViewModel();
// load all ceremonies that a user has access to
var ceremonies = ceremonyService.GetCeremonies(userId);
viewModel.RegistrationData = (from a in ceremonies
select new RegistrationData()
{
TermCode = a.TermCode,
Ceremony = a,
Registrants = a.RegistrationParticipations.Where(b => !b.Cancelled).Count(),
CancelledRegistrants = a.RegistrationParticipations.Where(b => b.Cancelled).Count(),
RegistrationPetitionsSubmitted = a.RegistrationPetitions.Count,
RegistrationPetitionsApproved = a.RegistrationPetitions.Where(b => b.IsApproved).Count(),
ExtraTicketPetitionsSubmitted = a.RegistrationParticipations.Where(b => b.ExtraTicketPetition != null).Count(),
ExtraTicketPetitionsApproved = a.RegistrationParticipations.Where(b => b.ExtraTicketPetition != null && b.ExtraTicketPetition.IsApproved).Count(),
TicketsPavilion = a.TicketCount,
TicketsBallroom = a.TicketStreamingCount,
TicketsByPetition = a.RegistrationParticipations.Where(b => b.ExtraTicketPetition != null && b.ExtraTicketPetition.IsApprovedCompletely).Sum(b => b.ExtraTicketPetition.TotalTickets)
}).ToList();
return viewModel;
}
public TicketController(ICeremonyService ceremonyService)
{
_ceremonyService = ceremonyService;
}
public ReportController(IRepositoryWithTypedId<TermCode, string> termRepository, IUserService userService, ICeremonyService ceremonyService, IMajorService majorService, IRepository<RegistrationParticipation> registrationParticipationRepository)
{
_termRepository = termRepository;
_userService = userService;
_ceremonyService = ceremonyService;
_majorService = majorService;
_registrationParticipationRepository = registrationParticipationRepository;
}
public static SurveyStatsViewModel Create(IRepository repository, ICeremonyService ceremonyService, string userId, int surveyId, int? ceremonyId = null)
{
var viewModel = new SurveyStatsViewModel()
{
Survey = repository.OfType<Survey>().GetById(surveyId),
Stats = new List<Tuple<SurveyField, Hashtable>>()
};
var userCeremonies = ceremonyService.GetCeremonyIds(userId);
// give back ceremonies user has access to
viewModel.Ceremonies = viewModel.Survey.Ceremonies.Where(a => userCeremonies.Contains(a.Id)).ToList(); //OK, I think we need to keep this for ones done before we had multi surveys per ceremony
var otherCeremonies = repository.OfType<Ceremony>().Queryable.Where(a => userCeremonies.Contains(a.Id) && a.CeremonySurveys.Any(b => b.Survey == viewModel.Survey)).ToList();
viewModel.Ceremonies.AddRange(otherCeremonies);
viewModel.Ceremonies = viewModel.Ceremonies.Distinct().ToList();
// only one ceremony
if (viewModel.Ceremonies.Count == 1 && !ceremonyId.HasValue)
{
ceremonyId = viewModel.Ceremonies.First().Id;
}
// verify the user's access to the selected ceremony
if (ceremonyId.HasValue && ceremonyService.HasAccess(ceremonyId.Value, userId))
{
viewModel.Ceremony = repository.OfType<Ceremony>().GetById(ceremonyId.Value);
// calculate the stats
foreach (var field in viewModel.Survey.SurveyFields.Where(a => a.SurveyFieldType.Answerable).OrderBy(a => a.Order))
{
var stat = new Hashtable();
// put in all the options
if (field.SurveyFieldType.FixedAnswers && field.SurveyFieldType.Name != "Boolean/Other")
{
foreach (var option in field.SurveyFieldOptions.OrderBy(a => a.Id))
{
stat.Add(option.Name, 0);
}
}
var answers = viewModel.Ceremony != null
? field.SurveyAnswers.Where(a => a.RegistrationSurvey.Ceremony == viewModel.Ceremony)
: field.SurveyAnswers;
foreach (var ans in answers)
{
if (field.SurveyFieldType.HasMultiAnswer)
{
if (!string.IsNullOrEmpty(ans.Answer))
{
var results = ans.Answer.Split('|');
foreach (var a in results)
{
if (!string.IsNullOrEmpty(a))
{
if (stat.ContainsKey(a))
{
var count = (int)stat[a];
stat[a] = count + 1;
}
else
{
stat.Add(a, 1);
}
}
}
}
}
else
{
if (!string.IsNullOrEmpty(ans.Answer))
{
if (stat.ContainsKey(ans.Answer))
{
var count = (int)stat[ans.Answer];
stat[ans.Answer] = count + 1;
}
else
{
stat.Add(ans.Answer, 1);
}
}
}
}
viewModel.Stats.Add(new Tuple<SurveyField, Hashtable>(field, stat));
}
}
return viewModel;
}
public RegistrationService(IRepository<Registration> registrationRepository, ICeremonyService ceremonyService, IRepository<RegistrationParticipation> registrationParticipationRepository)
{
_registrationRepository = registrationRepository;
_ceremonyService = ceremonyService;
_registrationParticipationRepository = registrationParticipationRepository;
}
public TransferRequestController(ICeremonyService ceremonyService, IErrorService errorService, IEmailService emailService)
{
_ceremonyService = ceremonyService;
_errorService = errorService;
_emailService = emailService;
}
public SurveyController(ICeremonyService ceremonyService, IExcelService excelService)
{
_ceremonyService = ceremonyService;
_excelService = excelService;
}
public TemplateController(ILetterGenerator letterGenerator, ICeremonyService ceremonyService)
{
_letterGenerator = letterGenerator;
_ceremonyService = ceremonyService;
}