public void SearchStudent()
{
try
{
string firstName = View.GetFirstName();
string lastName = View.GetLastName();
string phone = View.GetPhone();
string email = View.GetEmail();
var bl = Service.Get <IStudentBusinessLogic>();
var filter = new StudentFilter(firstName, lastName, phone, email);
IEnumerable <ListStudentGridViewModel> gridData = bl.GetStudents(filter);
if (gridData == null)
{
gridData = new List <ListStudentGridViewModel>();
}
else
{
gridData = new List <ListStudentGridViewModel>(gridData);
}
View.SetGridData(gridData);
}
catch (Exception ex)
{
View.ShowError(ex);
}
}
// GET: Student
public ActionResult Index()
{
var filter = new StudentFilter();
var result = bl.GetStudents(filter);
return(View(result));
}
public async Task <IList <Student> > GetStudentsAsync(StudentFilter studentFilter)
{
IEnumerable <Student> temp = students;
if (studentFilter != default(StudentFilter))
{
if (!string.IsNullOrWhiteSpace(studentFilter.Name))
{
temp = temp.Where(s => s.Name.ToUpperInvariant() == studentFilter.Name.ToUpperInvariant());
}
if (!string.IsNullOrWhiteSpace(studentFilter.Group))
{
temp = temp.Where(s => s.GroupName.ToUpperInvariant() == studentFilter.Group.ToUpperInvariant() | studentFilter.Group == "Group Any");
}
if (studentFilter.Birthdate != default(DateTime))
{
temp = temp.Where(s => s.Birthdate == studentFilter.Birthdate);
}
}
await Task.Delay(1000);
return(temp.ToList());
}
public async Task <int> Count(StudentFilter studentFilter)
{
IQueryable <StudentDAO> studentDAOs = tFContext.Student;
studentDAOs = DynamicFilter(studentDAOs, studentFilter);
return(await studentDAOs.CountAsync());
}
protected IQuery <StudentDTO> CreateQuery(StudentFilter filter)
{
var query = StudentListQuery;
query.Filter = filter;
return(query);
}
public IPagedList <SearchStudentDTO> SearchStudent(StudentFilter filter)
{
var data = GetData(filter);
filter.FilteredRecordCount = data.Count();
var dataDTO = data.Select(a => new SearchStudentDTO
{
StudentId = a.StudentId,
StudentNo = a.StudentNo,
LastName = a.LastName,
FirstName = a.FirstName,
MiddleName = a.MiddleName,
Birthday = a.Birthday,
Address = a.Address,
Gender = a.Gender.Description,
IsPaid = a.IsPaid ? "Yes":"No",
YearLevel = a.YearLevel.ToString(),
Remarks = a.Remarks,
CreatedOn = a.CreatedOn,
CreatedBy = a.CreatedByAppUser.FirstName + " " + a.CreatedByAppUser.LastName,
});;
dataDTO = QueryHelper.Ordering(dataDTO, filter.SortColumn, filter.SortDirection != "asc", false);
return(dataDTO.ToPagedList(filter.Page, filter.PageSize));
}
public async Task <int> Count(StudentFilter filter)
{
IQueryable <StudentDAO> studentDAOs = examRegContext.Student.AsNoTracking();
studentDAOs = DynamicFilter(studentDAOs, filter);
return(await studentDAOs.CountAsync());
}
private IQueryable <StudentDAO> DynamicFilter(IQueryable <StudentDAO> query, StudentFilter filter)
{
if (filter == null)
{
return(query.Where(q => 1 == 0));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.StudentNumber != null)
{
query = query.Where(q => q.StudentNumber, filter.StudentNumber);
}
if (filter.LastName != null)
{
query = query.Where(q => q.LastName, filter.LastName);
}
if (filter.GivenName != null)
{
query = query.Where(q => q.GivenName, filter.GivenName);
}
if (filter.Birthday != null)
{
query = query.Where(q => q.Birthday, filter.Birthday);
}
return(query);
}
public async Task <List <StudentDTO> > List([FromBody] StudentFilterDTO studentFilterDTO)
{
StudentFilter studentFilter = new StudentFilter
{
Identify = new StringFilter {
StartsWith = studentFilterDTO.Identify
},
Name = new StringFilter {
Contains = studentFilterDTO.Name
},
ProvinceId = new GuidFilter {
Equal = studentFilterDTO.ProvinceId
},
HighSchoolId = new GuidFilter {
Equal = studentFilterDTO.HighSchoolId
},
Gender = studentFilterDTO.Gender,
Dob = new DateTimeFilter {
Equal = studentFilterDTO.Dob
},
Status = studentFilterDTO.Status,
Skip = studentFilterDTO.Skip,
Take = int.MaxValue
};
var students = await StudentService.List(studentFilter);
if (students == null)
{
return(new List <StudentDTO>());
}
return(students.Select(s => new StudentDTO
{
Id = s.Id,
Address = s.Address,
Dob = s.Dob.Date,
Gender = s.Gender,
Email = s.Email,
Identify = s.Identify,
PlaceOfBirth = s.PlaceOfBirth,
Name = s.Name,
Phone = s.Phone,
EthnicId = s.EthnicId,
EthnicName = s.EthnicName,
EthnicCode = s.EthnicCode,
HighSchoolId = s.HighSchoolId,
HighSchoolName = s.HighSchoolName,
HighSchoolCode = s.HighSchoolCode,
TownId = s.TownId,
TownCode = s.TownCode,
TownName = s.TownName,
DistrictId = s.DistrictId,
DistrictCode = s.DistrictCode,
DistrictName = s.DistrictName,
ProvinceId = s.ProvinceId,
ProvinceCode = s.ProvinceCode,
ProvinceName = s.ProvinceName,
Status = s.Status
}).ToList());
}
public async Task <Student> ResetPassword(Student student)
{
using (UOW.Begin())
{
try
{
StudentFilter filter = new StudentFilter
{
StudentNumber = new IntFilter {
Equal = student.StudentNumber
}
};
Student existingStudent = await UOW.StudentRepository.Get(filter);
existingStudent.Password = student.StudentNumber.ToString();
await UOW.StudentRepository.Update(existingStudent);
await UOW.Commit();
return(existingStudent);
}
catch (Exception e)
{
await UOW.Rollback();
student.AddError(nameof(StudentService), nameof(ResetPassword), CommonEnum.ErrorCode.SystemError);
return(student);
}
}
}
public async Task <JsonResult> Index(Paginator paginator, StudentFilter filter)
{
List <StudentViewModel> studentViewList = new List <StudentViewModel>();
try
{
IEnumerable <StudentDataModel> studentList = await _studentService.GetStudentList();
IEnumerable <GroupDataModel> groupList = await _groupService.GetGroupList();
studentViewList = studentList.Select(x => new StudentViewModel(x, groupList.Where(i => x.GroupsIdList.Contains(i.ID)))).ToList();
}
catch (Exception ex)
{
return(Json(new { error = ex.Message }));
}
if (paginator.PageNumber.HasValue && paginator.StudentsCountAtPage.HasValue && paginator.PageNumber > 0)
{
studentViewList = studentViewList.GetRange((paginator.PageNumber.Value - 1) * paginator.StudentsCountAtPage.Value, paginator.StudentsCountAtPage.Value);
}
if (studentViewList != null)
{
studentViewList = filter.FilterList(studentViewList);
}
JsonResult result = Json(studentViewList?.Select(s => new { id = s.Id, fullName = s.FullName, uniqId = s.UniqueName, groups = String.Join(',', s.GroupList.Select(i => i.Name)) }).ToList());
return(result);
}
public IEnumerable <ListStudentGridViewModel> GetStudents(StudentFilter filter)
{
using (var ctx = new ModelContext())
{
var query = ctx.Students.AsQueryable();
if (!string.IsNullOrWhiteSpace(filter.FirstName))
{
query = query.Where(x => x.firstname.StartsWith(filter.FirstName));
}
if (!string.IsNullOrWhiteSpace(filter.LastName))
{
query = query.Where(x => x.lastname.StartsWith(filter.LastName));
}
if (!string.IsNullOrWhiteSpace(filter.Phone))
{
query = query.Where(x => x.phone.StartsWith(filter.Phone));
}
if (!string.IsNullOrWhiteSpace(filter.Email))
{
query = query.Where(x => x.email.StartsWith(filter.Email));
}
return(query
.Select(x => new ListStudentGridViewModel
{
Identifier = x.Id,
FirstName = x.firstname,
LastName = x.lastname,
Phone = x.phone,
Email = x.email
})
.ToArray());
}
}
public IHttpActionResult GetAllStudents()
{
var bl = Service.Get <IStudentBusinessLogic>();
var filter = new StudentFilter();
var result = bl.GetStudents(filter);
return(Ok(result));
}
public JsonResult SearchStudent(StudentFilter filter)
{
var result = _studentService.SearchStudent(filter);
return(Json(new
{
data = result.ToList(),
totalRecordCount = filter.FilteredRecordCount
}, JsonRequestBehavior.AllowGet));
}
private IQueryable <StudentDAO> DynamicOrder(IQueryable <StudentDAO> query, StudentFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case StudentOrder.StudentNumber:
query = query.OrderBy(q => q.StudentNumber);
break;
case StudentOrder.LastName:
query = query.OrderBy(q => q.LastName);
break;
case StudentOrder.GivenName:
query = query.OrderBy(q => q.GivenName);
break;
default:
query = query.OrderBy(q => q.CX);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case StudentOrder.StudentNumber:
query = query.OrderByDescending(q => q.StudentNumber);
break;
case StudentOrder.LastName:
query = query.OrderByDescending(q => q.LastName);
break;
case StudentOrder.GivenName:
query = query.OrderByDescending(q => q.GivenName);
break;
default:
query = query.OrderByDescending(q => q.CX);
break;
}
break;
default:
query = query.OrderBy(q => q.CX);
break;
}
return(query.Skip(filter.Skip).Take(filter.Take));
}
public static void FilterStudents(SchoolContext ctx)
{
var studentsFilter = new StudentFilter
{
ContainsInName = new[] { "a", "b" },
EnrollmentMinDate = new DateTime(2002, 1, 1),
MinCourses = 1,
MaxCourses = 3
};
Mapper.Register(new StudentModelMapper());
//GetFilter() is extension method for IFilterExpression<Student> interface and it combines all expression into one using &&.
var students = ctx.Students.Where(studentsFilter.GetFilter()).Project().To <StudentModel>().ToList();
}
public async Task <List <Student> > List(StudentFilter studentFilter)
{
if (studentFilter == null)
{
return(new List <Student>());
}
IQueryable <StudentDAO> studentDAOs = tFContext.Student;
studentDAOs = DynamicFilter(studentDAOs, studentFilter);
studentDAOs = DynamicOrder(studentDAOs, studentFilter);
var students = await DynamicSelect(studentDAOs);
return(students);
}
private void Confirm()
{
StudentFilter studentFilter = new StudentFilter()
{
Name = this.nameLayout.EditText.Text,
Group = this.groupLayout.EditText.Text,
Birthdate = this.birthdate
};
this.FragmentManager
.BeginTransaction()
.Replace(Resource.Id.main_container, new StudentListFragment(studentFilter))
.Commit();
}
// GET: Students
public ActionResult Index(int?page, StudentFilter input)
{
Log.Info($"{CONTROLLER}{INDEX_ACTION}. Page to show: {page??1} students with status:{input.Status}");
if (!this.ModelState.IsValid)
{
Log.Error($"{CONTROLLER}{INDEX_ACTION}. Model is not valid status binded was: {input.Status}");
TempData.AddErrorMessage("Please input valid status for students");
return(this.RedirectToAction("Index", "Home", input));
}
try
{
if (input.Status != -1)
{
PreviousStatus = input.Status;
}
int queryStatus = input.Status == -1
? PreviousStatus
: input.Status;
var pageNumber = page ?? 1;
var model = this.studentsService.GetAllByStatus(queryStatus);
string filterStatus = FillStatus(PreviousStatus);
if (model == null)
{
Log.Info($"{CONTROLLER}{INDEX_ACTION}. No students with status: {filterStatus} were retrieved.");
TempData.AddErrorMessage($"Students with status: {filterStatus} were not found.");
return(RedirectToAction("Index", "Home"));
}
var onePageFromModel = model.ToPagedList(pageNumber, PAGE_SIZE);
Log.Info($"{CONTROLLER}{INDEX_ACTION}. Student with status {filterStatus} were retrieved. Total count: {model.Count()}");
TempData.AddSuccessMessage($"Filter for {filterStatus} students, page: {pageNumber}!");
return(View(onePageFromModel));
}
catch (System.Exception ex)
{
Log.Error($"{CONTROLLER}{INDEX_ACTION}. Exception thrown", ex);
return(View("Error"));
}
}
public async Task <byte[]> ExportStudent()
{
// Lấy dữ liệu trong database
StudentFilter studentFilter = new StudentFilter()
{
OrderBy = StudentOrder.StudentNumber
};
List <Student> students = await UOW.StudentRepository.List(studentFilter);
// Mở excelPackage
using (ExcelPackage excel = new ExcelPackage())
{
// đặt header
var studentHeaders = new List <string[]>()
{
new string[]
{
"STT",
"Mã số sinh viên",
"Họ",
"Tên",
"Ngày sinh",
"Email",
"Tài khoản",
"Mật khẩu"
}
};
// tạo data
List <object[]> data = new List <object[]>();
for (int i = 0; i < students.Count; i++)
{
data.Add(new object[] {
i + 1,
students[i].StudentNumber,
students[i].LastName,
students[i].GivenName,
students[i].Birthday.ToString("dd-MM-yyyy"),
students[i].Email,
students[i].Username,
students[i].Password
});
}
// tạo worksheet
excel.GenerateWorksheet("Sinh viên", studentHeaders, data);
// trả về dữ liệu dạng byte
return(excel.GetAsByteArray());
}
}
public IHttpActionResult GetFiltered([FromBody] StudentFilter filter)
{
try
{
if (filter != null)
{
return(Ok(new { StatusCode = 200, Students = studentService.GetStudents(filter) }));
}
throw new OperationException(ErrorEnum.InCorrectParams);
}
catch (OperationException e)
{
var errorURI = $"{Request.RequestUri.Authority}/api/error/Get?id={e.Status}";
return(Ok(new { e.StatusCode, Info = errorURI }));
}
}
public async Task <HttpResponseMessage> GetStudentsAsync([FromUri] StudentFilter filter, [FromUri] StudentSort sort, [FromUri] StudentPage page)
{
if (filter != null && !filter.EmptyFilterString())
{
filter.StringToNameAndSurname();
}
StudentList = await studentService.ReadDataAsync(filter, sort, page);
if (StudentList.Count() == 0)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
Students = mapper.Map <List <Student> >(StudentList);
return(Request.CreateResponse(HttpStatusCode.OK, Students));
}
private IQueryable <Student> GetData(StudentFilter filter)
{
var data = GetAll.Where(a => a.IsActive);
//Filter
if (!string.IsNullOrWhiteSpace(filter.LastName))
{
filter.LastName = filter.LastName.Trim();
data = data.Where(a => a.LastName.Contains(filter.LastName));
}
if (!string.IsNullOrWhiteSpace(filter.FirstName))
{
filter.FirstName = filter.FirstName.Trim();
data = data.Where(a => a.FirstName.Contains(filter.FirstName));
}
if (!string.IsNullOrWhiteSpace(filter.MiddleName))
{
filter.MiddleName = filter.MiddleName.Trim();
data = data.Where(a => a.MiddleName.Contains(filter.MiddleName));
}
if (!string.IsNullOrWhiteSpace(filter.StudentNo))
{
filter.StudentNo = filter.StudentNo.Trim();
data = data.Where(a => a.StudentNo.Contains(filter.StudentNo));
}
if (!string.IsNullOrWhiteSpace(filter.Address))
{
filter.Address = filter.Address.Trim();
data = data.Where(a => a.Address.Contains(filter.Address));
}
if (filter.GenderId != null)
{
data = data.Where(a => a.GenderId == filter.GenderId);
}
//if (filter.ReligionId != null)
//{
// data = data.Where(a => a.ReligionId == filter.ReligionId);
//}
//if (!string.IsNullOrWhiteSpace(filter.CreatedBy))
//{
// filter.CreatedBy = filter.CreatedBy.Trim();
// data = data.Where(a => (a.CreatedByAppUser.FirstName + " "
// + a.CreatedByAppUser.LastName)
// .Trim().Contains(filter.CreatedBy));
//}
return(data);
}
private IQueryable <StudentDAO> DynamicOrder(IQueryable <StudentDAO> query, StudentFilter studentFilter)
{
switch (studentFilter.OrderType)
{
case OrderType.ASC:
switch (studentFilter.OrderBy)
{
case StudentOrder.Identify:
query = query.OrderBy(q => q.Identify);
break;
case StudentOrder.Name:
query = query.OrderBy(q => q.Name);
break;
default:
query = query.OrderBy(q => q.CX);
break;
}
break;
case OrderType.DESC:
switch (studentFilter.OrderBy)
{
case StudentOrder.Identify:
query = query.OrderByDescending(q => q.Identify);
break;
case StudentOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
default:
query = query.OrderByDescending(q => q.CX);
break;
}
break;
default:
query = query.OrderBy(q => q.CX);
break;
}
query = query.Skip(studentFilter.Skip).Take(studentFilter.Take);
return(query);
}
private IQueryable <StudentDAO> DynamicFilter(IQueryable <StudentDAO> query, StudentFilter studentFilter)
{
if (studentFilter == null)
{
return(query.Where(q => 1 == 0));
}
if (studentFilter.Id != null)
{
query = query.Where(q => q.Id, studentFilter.Id);
}
if (studentFilter.Name != null)
{
query = query.Where(q => q.Name, studentFilter.Name);
}
if (studentFilter.Identify != null)
{
query = query.Where(q => q.Identify, studentFilter.Identify);
}
if (studentFilter.Email != null)
{
query = query.Where(q => q.Email, studentFilter.Email);
}
if (studentFilter.ProvinceId != null)
{
query = query.Where(q => q.Town.District.ProvinceId, studentFilter.ProvinceId);
}
if (studentFilter.HighSchoolId != null)
{
query = query.Where(q => q.HighSchoolId, studentFilter.HighSchoolId);
}
if (studentFilter.Dob != null)
{
query = query.Where(q => q.Dob.Date, studentFilter.Dob);
}
if (studentFilter.Gender.HasValue)
{
query = query.Where(q => q.Gender.Equals(studentFilter.Gender.Value));
}
if (studentFilter.Status.HasValue)
{
query = query.Where(q => q.Status.Equals(studentFilter.Status.Value));
}
return(query);
}
public List <Student> GetPaginatedStudents(StudentFilter sfilter, PaginationFilter pfilter)
{
var students = GetStudents(sfilter);
if (pfilter.Offset > 0)
{
students = students.Skip(pfilter.Offset).ToList();
}
if (pfilter.Limit > 0)
{
students = students.Take(pfilter.Limit).ToList();
}
if (pfilter.Sort)
{
students = students.OrderBy(s => s.Name).ToList();
}
return(students.ToList());
}
private async Task <bool> ValidateId(Student student)
{
StudentFilter filter = new StudentFilter
{
Id = new GuidFilter {
Equal = student.Id
}
};
int count = await UOW.StudentRepository.Count(filter);
if (count == 0)
{
student.AddError(nameof(StudentValidator), nameof(student.StudentNumber), ERROR.NotExisted);
return(false);
}
return(true);
}
public async Task <IEnumerable <Student> > FilterAsync(StudentFilter filter, bool track = false)
{
var query = _context.Students.OrderBy(s => s.CreatedAt).AsQueryable();
if (!track)
{
query = query.AsNoTracking();
}
if (filter.FullObject)
{
query = FullStudentQuery().Invoke(query);
}
query = filter.ApplyToQuery(query);
return(await query.ToListAsync());
}
/// <summary>
/// 根据postid查询筛选标签
/// </summary>
/// <param name="postId">岗位id</param>
/// <returns></returns>
public async Task <StudentFilter> GetFilterByPostId(int postId)
{
var students = GetStudentsByPostId(postId);
PostManager postManager = new PostManager();
StudentFilter filter = new StudentFilter();
filter.schools = await students.Select(s => new SchoolModel()
{
id = s.SchoolID,
schoolName = s.School.SchoolName,
selected = false
}).Distinct().ToListAsync();
filter.grades = await students.Select(s => new GradeModel()
{
id = s.Grade,
gradeName = s.Grade + "级",
selected = false
}).Distinct().ToListAsync();
filter.majors = await students.Select(s => new MajorModel()
{
id = (int)s.Major,
majorName = s.Major.ToString(),
selected = false
}).Distinct().ToListAsync();
filter.educations = await students.Select(s => new EducationModel()
{
id = (int)s.Education,
educationName = s.Education.ToString(),
selected = false
}).Distinct().ToListAsync();
filter.intros = await students.Select(s =>
new IntroModel()
{
id = s.Signer.UserId,
introName = s.Signer.User.Name,
selected = false
}).Distinct().ToListAsync();
return(filter);
}
private async Task <bool> ValidateNotExist(Student student)
{
StudentFilter filter = new StudentFilter
{
Take = Int32.MaxValue,
StudentNumber = new IntFilter {
Equal = student.StudentNumber
}
};
int count = await UOW.StudentRepository.Count(filter);
if (count > 0)
{
student.AddError(nameof(StudentValidator), nameof(student.StudentNumber), ERROR.StudentNumberExisted);
return(false);
}
return(true);
}
