public StartupData GetStartupData()
{
var mps = ServiceLocator.MarkingPeriodService.GetMarkingPeriods(Context.SchoolYearId);
var markingPeriod = mps.Where(x => x.StartDate <= Context.NowSchoolYearTime).OrderBy(x => x.StartDate).LastOrDefault();
var startupData = new StartupData
{
UnshownNotificationsCount = ServiceLocator.NotificationService.GetUnshownNotifications().Count,
AttendanceReasons = ServiceLocator.AttendanceReasonService.List(),
AlternateScores = ServiceLocator.AlternateScoreService.GetAlternateScores(),
MarkingPeriods = ServiceLocator.MarkingPeriodService.GetMarkingPeriods(Context.SchoolYearId),
AlphaGrades = ServiceLocator.AlphaGradeService.GetAlphaGrades(),
GradingComments = ServiceLocator.GradingCommentService.GetGradingComments(),
SchoolOption = GetSchoolOption(),
Person = ServiceLocator.PersonService.GetPersonDetails(Context.PersonId.Value),
Classes = ((DemoClassService)ServiceLocator.ClassService).GetClassesSortedByPeriod(),
GradingPeriod = markingPeriod != null && Context.SchoolLocalId.HasValue
? ServiceLocator.GradingPeriodService.GetGradingPeriodDetails(markingPeriod.SchoolYearRef,
Context.NowSchoolYearTime.Date)
: null,
};
var alphaGradesForClasses = new Dictionary <int, IList <AlphaGrade> >();
var alphaGradesForClassStandards = new Dictionary <int, IList <AlphaGrade> >();
foreach (var classDetail in startupData.Classes)
{
alphaGradesForClasses.Add(classDetail.Id, ServiceLocator.AlphaGradeService.GetAlphaGrades());
alphaGradesForClassStandards.Add(classDetail.Id, ServiceLocator.AlphaGradeService.GetAlphaGrades());
}
startupData.AlphaGradesForClassStandards = alphaGradesForClassStandards;
startupData.AlphaGradesForClasses = alphaGradesForClasses;
return(startupData);
}
private void PrepareClassesAdvancedData(StartupData startupData)
{
var classesAdvancedData = new List <object>();
var allAlphaGrades = startupData.AlphaGrades;
var classAnnouncementTypes = SchoolLocator.ClassAnnouncementTypeService.GetClassAnnouncementTypes(startupData.Classes.Select(x => x.Id).ToList());
foreach (var classDetails in startupData.Classes)
{
var typesByClasses = classAnnouncementTypes.Where(x => x.ClassRef == classDetails.Id).ToList();
var alphaGradesForStandars = startupData.AlphaGradesForClassStandards[classDetails.Id];
if (alphaGradesForStandars.Count == 0 && Context.SchoolLocalId.HasValue)
{
alphaGradesForStandars = startupData.AlphaGradesForSchoolStandards
.Where(x => x.SchoolId == Context.SchoolLocalId.Value)
.Select(x => x.AlphaGrade).ToList();
}
var classAdvanceData = new
{
ClassId = classDetails.Id,
TypesByClass = ClassAnnouncementTypeViewData.Create(typesByClasses),
AlphaGrades =
classDetails.GradingScaleRef.HasValue
? startupData.AlphaGradesForClasses[classDetails.Id]
: allAlphaGrades,
AlphaGradesForStandards = alphaGradesForStandars
};
classesAdvancedData.Add(classAdvanceData);
}
PrepareJsonData(classesAdvancedData, ViewConstants.CLASSES_ADV_DATA);
}
private District PrepareCommonViewDataForSchoolPerson(StartupData startupData)
{
//TODO: render data for demo school
var district = PrepareCommonViewData();
ViewData[ViewConstants.UNSHOWN_NOTIFICATIONS_COUNT] = startupData.UnshownNotificationsCount;
var mps = startupData.MarkingPeriods;
MarkingPeriod markingPeriod = mps.Where(x => x.StartDate <= Context.NowSchoolYearTime).OrderBy(x => x.StartDate).LastOrDefault();
if (markingPeriod != null && SchoolLocator.Context.SchoolLocalId.HasValue)
{
PrepareJsonData(MarkingPeriodViewData.Create(markingPeriod), ViewConstants.MARKING_PERIOD);
var gradingPeriod = startupData.GradingPeriod;
if (gradingPeriod != null)
{
PrepareJsonData(ShortGradingPeriodViewData.Create(gradingPeriod), ViewConstants.GRADING_PERIOD);
}
}
PrepareJsonData(AlphaGradeViewData.Create(startupData.AlphaGrades), ViewConstants.ALPHA_GRADES);
PrepareJsonData(AlternateScoreViewData.Create(startupData.AlternateScores), ViewConstants.ALTERNATE_SCORES);
PrepareJsonData(GradingPeriodViewData.Create(startupData.GradingPeriods), ViewConstants.GRADING_PERIODS);
PrepareJsonData(MarkingPeriodViewData.Create(mps), ViewConstants.MARKING_PERIODS);
var sy = SchoolLocator.SchoolYearService.GetCurrentSchoolYear();
PrepareJsonData(SchoolYearViewData.Create(sy), ViewConstants.SCHOOL_YEAR);
PrepareJsonData(SchoolLocator.SchoolYearService.GetYears(), ViewConstants.YEARS);
return(district);
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
ApplicationInfo info = ApplicationConnection.GetApplicationInfo();
AppName.Text += info.Name;
AppId.Text += info.Id.ToString();
StartupData.SetActiveView(StartupData.Views[0]);
}
catch (HealthServiceException ex)
{
Error.Text += ex.ToString();
StartupData.SetActiveView(StartupData.Views[1]);
}
}
protected void Application_Start()
{
// AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
HangfireService.Instance.Start();
var context = new AnubisDbContext();
var applicationRoles = new List <AnubisDBMSUserRole>
{
new AnubisDBMSUserRole("Developers", "Developers", "Usuarios Developers", true),
};
Infraestructure.Security.StartupData.DefaultRoles(new Infraestructure.Security.Managers.AnubisDBMSRoleManager(new AnubisDBMSRoleStore(context)), applicationRoles);
StartupData.DefaultUsers(new Infraestructure.Security.Managers.AnubisDBMSUserManager(new Infraestructure.Security.Stores.AnubisDBMSUserStore(context)));
StartupData.DefaultRoles(new AnubisDBMSRoleManager(new AnubisDBMSRoleStore(context)), applicationRoles);
StartupData.DefaultUsers(new AnubisDBMSUserManager(new AnubisDBMSUserStore(context)));
context.Dispose();
}
// Cria a massa de dados inicial para uso do sistema caso seja uma instalação sem importação de dados
private Boolean CreateStartupData(DBAccess saAccess)
{
txtProcessInfo.Text += Environment.NewLine + "Criando massa de dados inicial no BD...";
const String executionFail = "Falha ao criar massa de dados. ";
// Verifica o acesso ao banco
if (saAccess == null)
{
txtProcessInfo.Text += Environment.NewLine + executionFail + "O acesso ao DB não está disponível. ";
return(false);
}
StartupData startupData = new StartupData(saAccess);
Boolean created = startupData.Create();
if (!created)
{
txtProcessInfo.Text += Environment.NewLine + executionFail + startupData.GetLastError();
return(false);
}
// Se não houve nenhuma falha retorna status de sucesso
return(true);
}
public StartupData GetStartupData(int schoolYearId, int personId, int roleId, DateTime now)
{
var ps = new Dictionary <string, object>
{
{ "@schoolYearId", schoolYearId },
{ "@personId", personId },
{ "@roleId", roleId },
{ "@now", now },
};
var res = new StartupData();
IOrderedEnumerable <ScheduleItem> schedule;
IList <ClassDetails> allClasses;
IList <GradingPeriod> gps;
using (var reader = ExecuteStoredProcedureReader("spGetStartupData", ps))
{
res.AlphaGrades = reader.ReadList <AlphaGrade>();
reader.NextResult();
res.AlternateScores = reader.ReadList <AlternateScore>();
reader.NextResult();
res.MarkingPeriods = reader.ReadList <MarkingPeriod>();
reader.NextResult();
gps = reader.ReadList <GradingPeriod>();
reader.NextResult();
res.Person = PersonDataAccess.ReadPersonDetailsData(reader);
reader.NextResult();
allClasses = ClassDataAccess.ReadClasses(reader);
reader.NextResult();
res.Rooms = reader.ReadList <Room>();
reader.NextResult();
schedule = reader.ReadList <ScheduleItem>().OrderBy(x => x.PeriodOrder).ThenBy(x => x.ClassName);
reader.NextResult();
res.SchoolOption = reader.Read() ? reader.Read <SchoolOption>() : null;
reader.NextResult();
res.GradingComments = reader.ReadList <GradingComment>();
reader.NextResult();
res.AttendanceReasons = AttendanceReasonDataAccess.ReadGetAttendanceReasonResult(reader);
reader.NextResult();
reader.Read();
res.UnshownNotificationsCount = SqlTools.ReadInt32(reader, "UnshownNotificationsCount");
reader.NextResult();
res.AlphaGradesForClasses = AlphaGradeDataAccess.ReadAlphaGradesForClasses(reader, allClasses.Select(x => x.Id).ToList());
reader.NextResult();
res.AlphaGradesForClassStandards = AlphaGradeDataAccess.ReadAlphaGradesForClasses(reader, allClasses.Select(x => x.Id).ToList());
reader.NextResult();
res.AlphaGradesForSchoolStandards = reader.ReadList <AlphaGradeDataAccess.SchoolAlphaGrade>();
}
res.GradingPeriod = gps.FirstOrDefault(x => x.StartDate <= now && x.EndDate >= now);
if (res.GradingPeriod == null)
{
res.GradingPeriod = gps.OrderByDescending(x => x.StartDate).FirstOrDefault();
}
var todayClasses = new List <ClassDetails>();
foreach (var classPeriod in schedule)
{
var c = allClasses.FirstOrDefault(x => x.Id == classPeriod.ClassId);
if (c != null && todayClasses.All(x => x.Id != c.Id))
{
todayClasses.Add(c);
}
}
var otherClasses = allClasses.Where(x => todayClasses.All(y => y.Id != x.Id)).OrderBy(x => x.Name).ToList();
res.Classes = todayClasses.Concat(otherClasses).ToList();
//res.AlphaGradesForClasses = new Dictionary<int, IList<AlphaGrade>>();
//res.AlphaGradesForClassStandards = new Dictionary<int, IList<AlphaGrade>>();
//foreach (var classDetail in allClasses)
//{
// res.AlphaGradesForClasses.Add(classDetail.Id, new List<AlphaGrade>());
// res.AlphaGradesForClassStandards.Add(classDetail.Id, new List<AlphaGrade>());
//}
//var agDic = res.AlphaGrades.ToDictionary(x => x.Id);
//foreach (var classAlphaGrade in agForClasses)
//{
// res.AlphaGradesForClasses[classAlphaGrade.ClassId].Add(agDic[classAlphaGrade.AlphaGradeId]);
//}
//foreach (var classAlphaGrade in agForClassStandards)
//{
// res.AlphaGradesForClassStandards[classAlphaGrade.ClassId].Add(agDic[classAlphaGrade.AlphaGradeId]);
//}
res.AttendanceReasons = res.AttendanceReasons.Where(x => x.AttendanceLevelReasons.Count > 0).ToList();
return(res);
}
