private void btnSave_Click(object sender, EventArgs e)
{
lblError.Text = "";
if (nddScore.Value <= 0)
{
lblError.Text = @"Score is required";
return;
}
if ((nddScore.Value % 1) != 0)
{
lblError.Text = @"Score is whole number";
return;
}
try
{
MatricNumber = AspNetUserService.GetStudentId((string)ddlMatricNumber.SelectedValue);
var studentDetails = $"{MatricNumber.FirstName} {MatricNumber.LastName}({MatricNumber.MatricNumber})";
var level = LevelService.GetItem(LevelId);
if (level.SectionModels != null && level.SectionModels.Count > 0)
{
var message = $@"Result Details {Environment.NewLine}Matric Number: {studentDetails}{Environment.NewLine}Course: {(string)ddlCourse.SelectedValue}{Environment.NewLine}Result: {nddScore.Value}";
var dialogResult = MessageBox.Show(message, @"Result Details", MessageBoxButtons.OK, MessageBoxIcon.Information);
if (dialogResult == DialogResult.OK)
{
var cId = CourseService.GetCourseByName((string)ddlCourse.SelectedValue).Id;
var courseWithResult = ResultService.CanSaveResult(MatricNumber.Id, cId);
if (courseWithResult != null)
{
MessageBox.Show(@"Student already have result", "Upload Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var result = new ResultModel
{
SectionId = level.SectionModels.FirstOrDefault().Id,
CourseId = cId,
StudentId = MatricNumber.Id,
Score = int.Parse(nddScore.Value.ToString()),
CreatedAt = DateTime.UtcNow
};
ResultService.Create(result, 0);
MessageBox.Show($@"Result of {studentDetails} is saved", "Upload successfull", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
MessageBox.Show(@"Ensure that LEVEL selected has a SESSION attached to it.", "Upload Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
catch (Exception ex)
{
_logger.Error("Error Message: " + ex.Message.ToString(), ex);
MessageBox.Show($@"Message: {ex.Message}{Environment.NewLine}Stack Message: {ex.StackTrace}", $@"Error Message from {typeof(SingleStudentSemesterResult)}");
}
}
private void btnUpload_Click(object sender, EventArgs e)
{
try
{
var level = LevelService.GetLevelId((string)ddlLevel2.SelectedValue);
if (level.SectionModels != null && level.SectionModels.Count > 0)
{
if (TextHelper.ContainsValue(new List <string>
{
beResultTemplate.Value
}))
{
lblError.Text = @"Result data is not selected";
return;
}
var dataRows = FileHelper.GetDataFromFile(beResultTemplate.Value);
var models = new List <ResultSingleStudentTemplateDownloadModel>();
var rowIndex = 2;
foreach (var row in dataRows)
{
try
{
var institutionModel = new ResultSingleStudentTemplateDownloadModel()
{
CourseCode = row["CourseCode"].ToString(),
Score = Convert.ToInt32(row["Score"].ToString()),
};
models.Add(institutionModel);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
gridSingleStudentResult.DataSource = models;
_resultTemplateDownloadModels = models;
MatricNumber = AspNetUserService.GetStudentId((string)ddlMatricNumber.SelectedValue);
gridSingleStudentResult.Enabled = true;
gridSingleStudentResult.AutoSizeColumnsMode = GridViewAutoSizeColumnsMode.Fill;
SemesterId = SemesterService.GetSemesterId((string)ddlSemester2.SelectedValue);
LevelId = level.Id;
}
else
{
MessageBox.Show(@"Ensure that LEVEL selected has a SESSION attached to it.", "Upload Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
catch (Exception ex)
{
_logger.Error("Error Message: " + ex.Message.ToString(), ex);
MessageBox.Show($@"Message: {ex.Message}{Environment.NewLine}Stack Message: {ex.StackTrace}", $@"Error Message from {typeof(SingleStudentSemesterResult)}");
}
}
public ListingController(
IUnitOfWorkAsync unitOfWorkAsync,
ISettingService settingService,
ICategoryService categoryService,
ICategoryListingTypeService categoryListingTypeService,
IListingService listingService,
IListingTypeService listingTypeService,
ICustomFieldService customFieldService,
ICustomFieldCategoryService customFieldCategoryService,
ICustomFieldListingService customFieldListingService,
IContentPageService contentPageService,
IOrderService orderService,
IDetailBedService detailBedService,
ITypeOfBedService typeOfBedService,
ISettingDictionaryService settingDictionaryService,
IEmailTemplateService emailTemplateService,
IPictureService pictureService,
IListingPictureService listingPictureservice,
IListingReviewService listingReviewService,
DataCacheService dataCacheService,
SqlDbService sqlDbService,
AspNetUserService aspNetUserService,
IListingObservationService listingObservationService)
{
_settingService = settingService;
_settingDictionaryService = settingDictionaryService;
_categoryService = categoryService;
_categoryListingTypeService = categoryListingTypeService;
_listingService = listingService;
_listingTypeService = listingTypeService;
_pictureService = pictureService;
_listingPictureservice = listingPictureservice;
_listingReviewService = listingReviewService;
_customFieldService = customFieldService;
_customFieldCategoryService = customFieldCategoryService;
_customFieldListingService = customFieldListingService;
_orderService = orderService;
_emailTemplateService = emailTemplateService;
_contentPageService = contentPageService;
_unitOfWorkAsync = unitOfWorkAsync;
_dataCacheService = dataCacheService;
_detailBedService = detailBedService;
_typeOfBedService = typeOfBedService;
_sqlDbService = sqlDbService;
_aspNetUserService = aspNetUserService;
_listingObservationService = listingObservationService;
}
public Controller CreateController(Type controllerType)
{
var userService = new AspNetUserService();
if (controllerType == typeof(HomeController))
{
return(new HomeController(userService));
}
throw new InvalidOperationException("Unknown type " + controllerType.FullName);
}
public ListingController(
IUnitOfWorkAsync unitOfWorkAsync,
ISettingService settingService,
ICategoryService categoryService,
IListingService listingService,
IPictureService pictureService,
IListingPictureService listingPictureservice,
IOrderService orderService,
IDetailBedService detailBedService,
ITypeOfBedService typeOfBedService,
ICustomFieldService customFieldService,
ICustomFieldCategoryService customFieldCategoryService,
ICustomFieldListingService customFieldListingService,
ISettingDictionaryService settingDictionaryService,
IListingStatService listingStatservice,
IListingReviewService listingReviewService,
IEmailTemplateService emailTemplateService,
IMessageService messageService,
IMessageThreadService messageThreadService,
IMessageParticipantService messageParticipantService,
IMessageReadStateService messageReadStateService,
DataCacheService dataCacheService,
SqlDbService sqlDbService,
AspNetUserService aspNerUserService)
{
_settingService = settingService;
_settingDictionaryService = settingDictionaryService;
_categoryService = categoryService;
_listingService = listingService;
_listingReviewService = listingReviewService;
_pictureService = pictureService;
_listingPictureservice = listingPictureservice;
_orderService = orderService;
_customFieldService = customFieldService;
_customFieldCategoryService = customFieldCategoryService;
_customFieldListingService = customFieldListingService;
_ListingStatservice = listingStatservice;
_emailTemplateService = emailTemplateService;
_messageService = messageService;
_messageParticipantService = messageParticipantService;
_messageReadStateService = messageReadStateService;
_messageThreadService = messageThreadService;
_dataCacheService = dataCacheService;
_sqlDbService = sqlDbService;
_detailBedService = detailBedService;
_typeOfBedService = typeOfBedService;
_unitOfWorkAsync = unitOfWorkAsync;
_aspNetUserService = aspNerUserService;
}
private void InitializeData()
{
var semesterItems = SemesterService.GetCount().OrderBy(c => c.Id).ToList();
var levels = LevelService.GetCount().OrderBy(c => c.Id).ToList();
ddlSemester.DataSource = semesterItems.ToList().Select(c => c.Name);
ddLevel.DataSource = levels.Select(c => c.Name);
ProcessCourseDataSourse(LevelId, SemesterId);
ddlMatricNumber.DataSource = AspNetUserService
.GetCount(Enum.GetName(typeof(RolesConstants.Enum), RolesConstants.Enum.Student))
.Select(c => c.MatricNumber);
nddScore.Value = 0;
}
public SingleStudentSemesterResult()
{
InitializeComponent();
var semesterItems = SemesterService.GetCount().OrderBy(c => c.Id).ToList();
var levels = LevelService.GetCount().OrderBy(c => c.Id).ToList();
ddlSemester.DataSource = semesterItems.ToList().Select(c => c.Name);
ddlSemester2.DataSource = semesterItems.ToList().Select(c => c.Name);
ddlLevel.DataSource = levels.Select(c => c.Name);
ddlLevel2.DataSource = levels.Select(c => c.Name);
ddlMatricNumber.DataSource = AspNetUserService
.GetCount(Enum.GetName(typeof(RolesConstants.Enum), RolesConstants.Enum.Student))
.Select(c => c.MatricNumber);
}
private void btnUpload_Click(object sender, EventArgs e)
{
try
{
LevelId = LevelService.GetLevelId((string)ddlLevel.SelectedValue).Id;
SemesterId = SemesterService.GetSemesterId((string)ddlSemester.SelectedValue);
Student = AspNetUserService.GetStudentId((string)ddlMatricNumber.SelectedValue);
List <ResultSingleStudentTemplateDownloadModel> forSemester = ResultService.GetStudentResultForSemester(Student.Id, LevelId, SemesterId);
gridSingleStudentResult.DataSource = forSemester;
gridSingleStudentResult.AutoSizeColumnsMode = GridViewAutoSizeColumnsMode.Fill;
}
catch (Exception ex)
{
_logger.Error("Error Message: " + ex.Message.ToString(), ex);
this.ShowMessageBox($@"Message: {ex.Message}{Environment.NewLine}Stack Message: {ex.StackTrace}", $@"Error Message from {typeof(SingleStudentSemesterResult)}");
}
}
private void Initialize()
{
var semesterItems = SemesterService.GetCount().OrderBy(c => c.Id).ToList();
var levels = LevelService.GetCount().OrderBy(c => c.Id).ToList();
ddlSemester.DataSource = semesterItems.ToList().Select(c => c.Name);
ddlLevel.DataSource = levels.Select(c => c.Name);
ddlMatricNumber.DataSource = AspNetUserService
.GetCount(Enum.GetName(typeof(RolesConstants.Enum), RolesConstants.Enum.Student))
.Select(c => c.MatricNumber);
ddlLevel.SelectedIndexChanged += (sender, args) => { LevelId = LevelService.GetLevelId((string)ddlLevel.SelectedValue).Id; };
ddlSemester.SelectedIndexChanged += (sender, args) =>
{
SemesterId = SemesterService.GetSemesterId((string)ddlSemester.SelectedValue);
};
ddlMatricNumber.SelectedIndexChanged += (sender, args) => { Student = AspNetUserService.GetStudentId((string)ddlMatricNumber.SelectedValue); };
LoadDataForResult();
}
private void btnLoadReport_Click(object sender, EventArgs e)
{
Student = AspNetUserService.GetStudentId((string)ddlMatricNumber.SelectedValue);
LevelId = LevelService.GetLevelId((string)ddlLevel.SelectedValue).Id;
SemesterId = SemesterService.GetSemesterId((string)ddlSemester.SelectedValue);
var result = ResultService.StudentSemesterResult(Student.Id, LevelId, SemesterId);
if (result == null)
{
this.ShowMessageBox("Can not load result at this time, please check selected values",
"Error processing result", MessageBoxButtons.OK, RadMessageIcon.Error);
return;
}
ReportDataSource studentDetails = new ReportDataSource("StudentDetails", new List <ReportStudentDetail>()
{
result.StudentDetail ?? new ReportStudentDetail(),
});
ReportDataSource reportStudentSemesterCourse = new ReportDataSource("ReportStudentSemesterCourse",
result.SemesterCourse
);
ReportDataSource reportGradeDetail = new ReportDataSource("ReportGradeDetail",
new List <ReportGradeDetail>()
{
result.GradeDetail ?? new ReportGradeDetail(),
}
);
reportViewer1.LocalReport.DataSources.Clear();
reportViewer1.LocalReport.DataSources.Add(reportGradeDetail);
reportViewer1.LocalReport.DataSources.Add(reportStudentSemesterCourse);
reportViewer1.LocalReport.DataSources.Add(studentDetails);
reportViewer1.RefreshReport();
}
public AllCourseStudent()
{
InitializeComponent();
var semesterItems = SemesterService.GetCount().OrderBy(c => c.Id).ToList();
var levels = LevelService.GetCount().OrderBy(c => c.Id).ToList();
ddlSemester.DataSource = semesterItems.ToList().Select(c => c.Name);
ddlLevel.DataSource = levels.Select(c => c.Name);
gridSingleStudentResult.Enabled = false;
ddlMatricNumber.DataSource = AspNetUserService
.GetCount(Enum.GetName(typeof(RolesConstants.Enum), RolesConstants.Enum.Student))
.Select(c => c.MatricNumber);
ddlLevel.SelectedIndexChanged += (sender, args) => { LevelId = LevelService.GetLevelId((string)ddlLevel.SelectedValue).Id; };
ddlSemester.SelectedIndexChanged += (sender, args) =>
{
SemesterId = SemesterService.GetSemesterId((string)ddlSemester.SelectedValue);
};
ddlMatricNumber.SelectedIndexChanged += (sender, args) => { Student = AspNetUserService.GetStudentId((string)ddlMatricNumber.SelectedValue); };
}
public ManageController(
IUnitOfWorkAsync unitOfWorkAsync,
ISettingService settingService,
ICategoryService categoryService,
IListingService listingService,
ICustomFieldService customFieldService,
ICustomFieldCategoryService customFieldCategoryService,
IContentPageService contentPageService,
IOrderService orderService,
ISettingDictionaryService settingDictionaryService,
IEmailTemplateService emailTemplateService,
DataCacheService dataCacheService,
SqlDbService sqlDbService,
IPluginFinder pluginFinder,
AspNetUserService aspNetUserService,
CountryService countryService)
{
_settingService = settingService;
_settingDictionaryService = settingDictionaryService;
_categoryService = categoryService;
_listingService = listingService;
_customFieldService = customFieldService;
_customFieldCategoryService = customFieldCategoryService;
_orderService = orderService;
_emailTemplateService = emailTemplateService;
_contentPageService = contentPageService;
_unitOfWorkAsync = unitOfWorkAsync;
_dataCacheService = dataCacheService;
_sqlDbService = sqlDbService;
_pluginFinder = pluginFinder;
_aspNetUserService = aspNetUserService;
_countryService = countryService;
}
public UsersController()
: base()
{
entityService = new AspNetUserService(base.identityDB);
organizationService = new OrganizationService(base.db);
}
public void AspNetUser_Get_With_Key_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPWebToolsDBContext dbTestDB = new CSSPWebToolsDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
GetParam getParam = new GetParam();
AspNetUserService aspNetUserService = new AspNetUserService(new GetParam(), dbTestDB, ContactID);
AspNetUser aspNetUser = (from c in aspNetUserService.GetRead() select c).FirstOrDefault();
Assert.IsNotNull(aspNetUser);
AspNetUser aspNetUserRet = null;
foreach (EntityQueryDetailTypeEnum entityQueryDetailTypeEnum in new List <EntityQueryDetailTypeEnum>()
{
EntityQueryDetailTypeEnum.Error, EntityQueryDetailTypeEnum.EntityOnly, EntityQueryDetailTypeEnum.EntityWeb, EntityQueryDetailTypeEnum.EntityReport
})
{
getParam.EntityQueryDetailType = entityQueryDetailTypeEnum;
if (entityQueryDetailTypeEnum == EntityQueryDetailTypeEnum.Error)
{
aspNetUserRet = aspNetUserService.GetAspNetUserWithAspNetUserID(aspNetUser.AspNetUserID, getParam);
Assert.IsNull(aspNetUserRet);
continue;
}
else if (entityQueryDetailTypeEnum == EntityQueryDetailTypeEnum.EntityOnly)
{
aspNetUserRet = aspNetUserService.GetAspNetUserWithAspNetUserID(aspNetUser.AspNetUserID, getParam);
}
else if (entityQueryDetailTypeEnum == EntityQueryDetailTypeEnum.EntityWeb)
{
aspNetUserRet = aspNetUserService.GetAspNetUserWithAspNetUserID(aspNetUser.AspNetUserID, getParam);
}
else if (entityQueryDetailTypeEnum == EntityQueryDetailTypeEnum.EntityReport)
{
aspNetUserRet = aspNetUserService.GetAspNetUserWithAspNetUserID(aspNetUser.AspNetUserID, getParam);
}
else
{
// nothing for now
}
// AspNetUser fields
Assert.IsFalse(string.IsNullOrWhiteSpace(aspNetUserRet.Id));
if (aspNetUserRet.Email != null)
{
Assert.IsFalse(string.IsNullOrWhiteSpace(aspNetUserRet.Email));
}
Assert.IsNotNull(aspNetUserRet.EmailConfirmed);
if (aspNetUserRet.PasswordHash != null)
{
Assert.IsFalse(string.IsNullOrWhiteSpace(aspNetUserRet.PasswordHash));
}
if (aspNetUserRet.SecurityStamp != null)
{
Assert.IsFalse(string.IsNullOrWhiteSpace(aspNetUserRet.SecurityStamp));
}
if (aspNetUserRet.PhoneNumber != null)
{
Assert.IsFalse(string.IsNullOrWhiteSpace(aspNetUserRet.PhoneNumber));
}
Assert.IsNotNull(aspNetUserRet.PhoneNumberConfirmed);
Assert.IsNotNull(aspNetUserRet.TwoFactorEnabled);
if (aspNetUserRet.LockoutEndDateUtc != null)
{
Assert.IsNotNull(aspNetUserRet.LockoutEndDateUtc);
}
Assert.IsNotNull(aspNetUserRet.LockoutEnabled);
Assert.IsNotNull(aspNetUserRet.AccessFailedCount);
Assert.IsFalse(string.IsNullOrWhiteSpace(aspNetUserRet.UserName));
if (entityQueryDetailTypeEnum == EntityQueryDetailTypeEnum.EntityOnly)
{
// AspNetUserWeb and AspNetUserReport fields should be null here
}
else if (entityQueryDetailTypeEnum == EntityQueryDetailTypeEnum.EntityWeb)
{
// AspNetUserWeb fields should not be null and AspNetUserReport fields should be null here
}
else if (entityQueryDetailTypeEnum == EntityQueryDetailTypeEnum.EntityReport)
{
// AspNetUserWeb and AspNetUserReport fields should NOT be null here
}
}
}
}
}
private void btnSaveResult_Click(object sender, EventArgs e)
{
try
{
var level = LevelService.GetItem(LevelId);
var semester = SemesterService.GetSemester(SemesterId).Name;
var course = CourseService.GetCourse(CourseId).Code;
if (level.SectionModels != null && level.SectionModels.Count > 0)
{
var message = $@"Upload Details {Environment.NewLine}Level: {level.Name}{Environment.NewLine}Semester: {semester}{Environment.NewLine}Course: {course}{Environment.NewLine}Number of student: {_resultTemplateDownloadModels.Count}";
var dialogResult = this.ShowMessageBox(message, @"Data Upload Details", MessageBoxButtons.OKCancel, RadMessageIcon.Info);
if (dialogResult == DialogResult.OK)
{
var results = new List <ResultModel>();
var studentProcessed = $@"Student Processed: {Environment.NewLine}";
var studentInDb = $@"Student with result: {Environment.NewLine}";
foreach (var resultSingleStudentTemplateDownloadModel in _resultTemplateDownloadModels)
{
var studentModel = AspNetUserService.GetStudentId(resultSingleStudentTemplateDownloadModel.MatricNumber);
var courseModel = CourseService.GetCourse(CourseId);
if (string.IsNullOrWhiteSpace(resultSingleStudentTemplateDownloadModel.MatricNumber))
{
continue;
}
if (courseModel == null)
{
continue;
}
var courseWithResult = ResultService.CanSaveResult(studentModel.Id, courseModel.Id);
if (courseWithResult != null)
{
studentInDb += $"{studentModel.MatricNumber}: {courseWithResult.Score} {Environment.NewLine}";
continue;
}
var result = new ResultModel
{
SectionId = level.SectionModels.FirstOrDefault().Id,
CourseId = courseModel.Id,
StudentId = studentModel.Id,
Score = resultSingleStudentTemplateDownloadModel.Score,
CreatedAt = DateTime.UtcNow
};
results.Add(result);
studentProcessed += $"{studentModel.MatricNumber}: {result.Score} {Environment.NewLine}";
}
ResultService.CreateBulk(results);
this.ShowMessageBox($@"{studentProcessed}{Environment.NewLine}{studentInDb}", @"Result Successed", MessageBoxButtons.OK, RadMessageIcon.Info);
}
}
else
{
this.ShowMessageBox(@"Ensure that LEVEL selected has a SESSION attached to it.", "Upload Error", MessageBoxButtons.OK, RadMessageIcon.Error);
}
}
catch (Exception ex)
{
_logger.Error("Error Message: " + ex.Message, ex);
this.ShowMessageBox($@"Message: {ex.Message}{Environment.NewLine}Stack Message: {ex.StackTrace}", $@"Error Message from {typeof(SingleStudentSemesterResult)}");
}
}
private void btnSave_Click(object sender, EventArgs e)
{
try
{
SemesterId = SemesterService.GetSemesterId((string)ddlSemester.SelectedValue);
var level = LevelService.GetLevelId((string)ddlLevel.SelectedValue);
LevelId = level.Id;
Student = AspNetUserService.GetStudentId((string)ddlMatricNumber.SelectedValue);
var data = (List <ResultSingleStudentTemplateDownloadModel>)gridSingleStudentResult.DataSource;
var oldResult = ResultService.GetStudentResultForSemester(Student.Id, LevelId, SemesterId);
var updateResult = false;
if (oldResult.Count == data.Count)
{
updateResult = true;
var dialog = this.ShowMessageBox(@"Student have results for this semester already, Could you like to update it.", "Result Compeletion", MessageBoxButtons.OKCancel, RadMessageIcon.Error);
if (dialog == DialogResult.Cancel)
{
return;
}
}
if (oldResult.Count < data.Count)
{
var dialog = this.ShowMessageBox($@"Student have {oldResult.Count} results for this semester already, could you like to save the rest.", "Result Processing", MessageBoxButtons.OKCancel, RadMessageIcon.Error);
if (dialog == DialogResult.Cancel)
{
return;
}
}
var newData = data.Except(oldResult, new ResultSingleStudentTemplateDownloadModelComparer()).ToList();
var message = string.Empty;
if (newData.Any())
{
List <ResultModel> resultModels = new List <ResultModel>();
foreach (var resultSingleCourseTemplateDownloadModel in newData)
{
var result = oldResult.FirstOrDefault(c =>
c.CourseCode.Equals(resultSingleCourseTemplateDownloadModel.CourseCode,
StringComparison.OrdinalIgnoreCase));
ResultModel model = null;
if (result != null)
{
if (CheckScore(resultSingleCourseTemplateDownloadModel))
{
return;
}
if (updateResult)
{
model = ResultService.GetByMatricNumberCourseCode(Student.MatricNumber, result.CourseCode);
model.Score = resultSingleCourseTemplateDownloadModel.Score;
}
if (updateResult)
{
message +=
$"{resultSingleCourseTemplateDownloadModel.CourseCode}: Old({result.Score}) - New({resultSingleCourseTemplateDownloadModel.Score}){Environment.NewLine}";
}
}
else
{
if (CheckScore(resultSingleCourseTemplateDownloadModel))
{
return;
}
var cId = CourseService.GetCourseByName(resultSingleCourseTemplateDownloadModel.CourseCode).Id;
model = new ResultModel
{
SectionId = level.SectionModels.FirstOrDefault().Id,
CourseId = cId,
StudentId = Student.Id,
Score = resultSingleCourseTemplateDownloadModel.Score,
CreatedAt = DateTime.UtcNow
};
message +=
$"{resultSingleCourseTemplateDownloadModel.CourseCode}: {resultSingleCourseTemplateDownloadModel.Score}{Environment.NewLine}";
}
if (model != null)
{
resultModels.Add(model);
}
}
if (!string.IsNullOrWhiteSpace(message))
{
var dialogResult = this.ShowMessageBox(message, "Result to process", MessageBoxButtons.OKCancel,
RadMessageIcon.Info);
if (dialogResult == DialogResult.OK)
{
if (updateResult)
{
ResultService.UpdateBulk(resultModels);
}
else
{
ResultService.CreateBulk(resultModels);
}
this.ShowMessageBox($"{newData.Count} processed", "Result after processing",
MessageBoxButtons.OKCancel);
gridSingleStudentResult.DataSource = ResultService.GetStudentResultForSemester(Student.Id, LevelId, SemesterId);
}
}
return;
}
message = "No result to update";
this.ShowMessageBox(message, "Update Process", MessageBoxButtons.OK, RadMessageIcon.Info);
}
catch (Exception ex)
{
_logger.Error("Error Message: " + ex.Message, ex);
this.ShowMessageBox($@"Message: {ex.Message}{Environment.NewLine}Stack Message: {ex.StackTrace}", $@"Error Message from {typeof(AllStudentCourseResult)}");
}
}
public void AspNetUser_CRUD_And_Properties_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPWebToolsDBContext dbTestDB = new CSSPWebToolsDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
AspNetUserService aspNetUserService = new AspNetUserService(new GetParam(), dbTestDB, ContactID);
int count = 0;
if (count == 1)
{
// just so we don't get a warning during compile [The variable 'count' is assigned but its value is never used]
}
AspNetUser aspNetUser = GetFilledRandomAspNetUser("");
// -------------------------------
// -------------------------------
// CRUD testing
// -------------------------------
// -------------------------------
count = aspNetUserService.GetRead().Count();
Assert.AreEqual(aspNetUserService.GetRead().Count(), aspNetUserService.GetEdit().Count());
aspNetUserService.Add(aspNetUser);
if (aspNetUser.HasErrors)
{
Assert.AreEqual("", aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(true, aspNetUserService.GetRead().Where(c => c == aspNetUser).Any());
aspNetUserService.Update(aspNetUser);
if (aspNetUser.HasErrors)
{
Assert.AreEqual("", aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(count + 1, aspNetUserService.GetRead().Count());
aspNetUserService.Delete(aspNetUser);
if (aspNetUser.HasErrors)
{
Assert.AreEqual("", aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(count, aspNetUserService.GetRead().Count());
// -------------------------------
// -------------------------------
// Properties testing
// -------------------------------
// -------------------------------
// -----------------------------------
// [Key]
// Is NOT Nullable
// [StringLength(128))]
// aspNetUser.Id (String)
// -----------------------------------
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("");
aspNetUser.Id = 0;
aspNetUserService.Update(aspNetUser);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, CSSPModelsRes.AspNetUserId), aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("");
aspNetUser.Id = 10000000;
aspNetUserService.Update(aspNetUser);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, CSSPModelsRes.AspNetUser, CSSPModelsRes.AspNetUserId, aspNetUser.Id.ToString()), aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is Nullable
// [StringLength(256))]
// aspNetUser.Email (String)
// -----------------------------------
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("");
aspNetUser.Email = GetRandomString("", 257);
Assert.AreEqual(false, aspNetUserService.Add(aspNetUser));
Assert.AreEqual(string.Format(CSSPServicesRes._MaxLengthIs_, CSSPModelsRes.AspNetUserEmail, "256"), aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, aspNetUserService.GetRead().Count());
// -----------------------------------
// Is NOT Nullable
// aspNetUser.EmailConfirmed (Boolean)
// -----------------------------------
// -----------------------------------
// Is Nullable
// [StringLength(256))]
// aspNetUser.PasswordHash (String)
// -----------------------------------
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("");
aspNetUser.PasswordHash = GetRandomString("", 257);
Assert.AreEqual(false, aspNetUserService.Add(aspNetUser));
Assert.AreEqual(string.Format(CSSPServicesRes._MaxLengthIs_, CSSPModelsRes.AspNetUserPasswordHash, "256"), aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, aspNetUserService.GetRead().Count());
// -----------------------------------
// Is Nullable
// [StringLength(256))]
// aspNetUser.SecurityStamp (String)
// -----------------------------------
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("");
aspNetUser.SecurityStamp = GetRandomString("", 257);
Assert.AreEqual(false, aspNetUserService.Add(aspNetUser));
Assert.AreEqual(string.Format(CSSPServicesRes._MaxLengthIs_, CSSPModelsRes.AspNetUserSecurityStamp, "256"), aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, aspNetUserService.GetRead().Count());
// -----------------------------------
// Is Nullable
// [StringLength(256))]
// aspNetUser.PhoneNumber (String)
// -----------------------------------
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("");
aspNetUser.PhoneNumber = GetRandomString("", 257);
Assert.AreEqual(false, aspNetUserService.Add(aspNetUser));
Assert.AreEqual(string.Format(CSSPServicesRes._MaxLengthIs_, CSSPModelsRes.AspNetUserPhoneNumber, "256"), aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, aspNetUserService.GetRead().Count());
// -----------------------------------
// Is NOT Nullable
// aspNetUser.PhoneNumberConfirmed (Boolean)
// -----------------------------------
// -----------------------------------
// Is NOT Nullable
// aspNetUser.TwoFactorEnabled (Boolean)
// -----------------------------------
// -----------------------------------
// Is Nullable
// [CSSPAfter(Year = 1980)]
// aspNetUser.LockoutEndDateUtc (DateTime)
// -----------------------------------
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("");
aspNetUser.LockoutEndDateUtc = new DateTime(1979, 1, 1);
aspNetUserService.Add(aspNetUser);
Assert.AreEqual(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, CSSPModelsRes.AspNetUserLockoutEndDateUtc, "1980"), aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// aspNetUser.LockoutEnabled (Boolean)
// -----------------------------------
// -----------------------------------
// Is NOT Nullable
// [Range(0, 10000)]
// aspNetUser.AccessFailedCount (Int32)
// -----------------------------------
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("");
aspNetUser.AccessFailedCount = -1;
Assert.AreEqual(false, aspNetUserService.Add(aspNetUser));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, CSSPModelsRes.AspNetUserAccessFailedCount, "0", "10000"), aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, aspNetUserService.GetRead().Count());
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("");
aspNetUser.AccessFailedCount = 10001;
Assert.AreEqual(false, aspNetUserService.Add(aspNetUser));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, CSSPModelsRes.AspNetUserAccessFailedCount, "0", "10000"), aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, aspNetUserService.GetRead().Count());
// -----------------------------------
// Is NOT Nullable
// [StringLength(256))]
// aspNetUser.UserName (String)
// -----------------------------------
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("UserName");
Assert.AreEqual(false, aspNetUserService.Add(aspNetUser));
Assert.AreEqual(1, aspNetUser.ValidationResults.Count());
Assert.IsTrue(aspNetUser.ValidationResults.Where(c => c.ErrorMessage == string.Format(CSSPServicesRes._IsRequired, CSSPModelsRes.AspNetUserUserName)).Any());
Assert.AreEqual(null, aspNetUser.UserName);
Assert.AreEqual(count, aspNetUserService.GetRead().Count());
aspNetUser = null;
aspNetUser = GetFilledRandomAspNetUser("");
aspNetUser.UserName = GetRandomString("", 257);
Assert.AreEqual(false, aspNetUserService.Add(aspNetUser));
Assert.AreEqual(string.Format(CSSPServicesRes._MaxLengthIs_, CSSPModelsRes.AspNetUserUserName, "256"), aspNetUser.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, aspNetUserService.GetRead().Count());
// -----------------------------------
// Is NOT Nullable
// [NotMapped]
// aspNetUser.HasErrors (Boolean)
// -----------------------------------
// No testing requied
// -----------------------------------
// Is NOT Nullable
// [NotMapped]
// aspNetUser.ValidationResults (IEnumerable`1)
// -----------------------------------
// No testing requied
}
}
}
