// GET: EnrollStudents/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EnrollStudent enrollStudent = db.enrollStudent.Find(id);
if (enrollStudent == null)
{
return(HttpNotFound());
}
return(View(enrollStudent));
}
public ActionResult EnrollCourseForStudents(EnrollStudent enroll)
{
if (ModelState.IsValid)
{
ViewBag.Response = studentManager.EnrollCourse(enroll);
}
else
{
ViewBag.Response = "Empty";
}
ViewBag.Students = studentManager.GetAllStudentsForDropDown();
ModelState.Clear();
return(View());
}
public async Task Create(EnrollStudent model, SqlTransaction sqlTransaction, int idEnrollment)
{
await using var command = new SqlCommand(InsertStudentQuery, sqlTransaction.Connection)
{
CommandType = CommandType.Text,
Transaction = sqlTransaction
};
command.Parameters.AddWithValue("@IndexNumber", model.IndexNumber);
command.Parameters.AddWithValue("@FirstName", model.FirstName);
command.Parameters.AddWithValue("@LastName", model.LastName);
command.Parameters.AddWithValue("@BirthDate", model.BirthDate);
command.Parameters.AddWithValue("@IdEnrollment", idEnrollment);
await command.ExecuteNonQueryAsync();
}
public int EnrollStudent(EnrollStudent enrollStudent)
{
string query = "INSERT INTO EnrollStudent (StudentRegEId, CourseId,EnrollTime,Available)" +
" VALUES (@studentId, @courseId,@enrollTime,@available)";
Gateway gateway = new Gateway(query);
gateway.SqlCommand.Parameters.Clear();
gateway.SqlCommand.Parameters.AddWithValue("@studentId", enrollStudent.StudentRegEId);
gateway.SqlCommand.Parameters.AddWithValue("@courseId", enrollStudent.CourseId);
gateway.SqlCommand.Parameters.AddWithValue("@enrollTime", enrollStudent.EnrollTime);
gateway.SqlCommand.Parameters.AddWithValue("@available", 1);
int rowAffected = gateway.SqlCommand.ExecuteNonQuery();
return(rowAffected);
}
// GET: EnrollStudents/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EnrollStudent enrollStudent = db.enrollStudent.Find(id);
if (enrollStudent == null)
{
return(HttpNotFound());
}
ViewBag.GenrateClassID = new SelectList(db.genrateClass, "GenrateClassID", "Name", enrollStudent.GenrateClassID);
ViewBag.StudentID = new SelectList(db.Students, "ID", "FirstMidName", enrollStudent.StudentID);
return(View(enrollStudent));
}
public async Task It_Should_Add_The_Student()
{
var studentRepository = new Mock <IStudentRepository>();
var hash = new Mock <IHash>();
hash.Setup(it => it.Make(It.IsAny <string>())).ReturnsAsync("hash");
var enroll = new EnrollStudent(studentRepository.Object, hash.Object);
var data = new EnrollStudentDto("11100011100", "Frank", "*****@*****.**", "123456");
await enroll.Execute(data);
studentRepository.Verify(it => it.Add(It.IsAny <Student>()), Times.Once);
}
public static void Start()
{
if (_started)
{
return;
}
_started = true;
NetworkComms.DisableLogging();
var serializer = DPSManager.GetDataSerializer <ProtobufSerializer>();
NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(serializer,
NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options);
PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast);
NetworkComms.AppendGlobalIncomingPacketHandler <AndroidInfo>(AndroidInfo.GetHeader(), AndroidHandler.HandShakeHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <StudentInfoRequest>(StudentInfoRequest.GetHeader(), AndroidHandler.StudentInfoRequested);
NetworkComms.AppendGlobalIncomingPacketHandler <EndPointInfo>(EndPointInfo.GetHeader(), HandShakeHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <GetWork>(GetWork.GetHeader(), GetWorkHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <Login>(Login.GetHeader(), LoginHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <Logout>(Logout.GetHeader(), LogoutHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <SchedulesRequest>(SchedulesRequest.GetHeader(), AndroidHandler.ScheduleRequestHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <EnrollRequest>(EnrollRequest.GetHeader(), AndroidHandler.EnrollRequestHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <RegisterStudent>(RegisterStudent.GetHeader(), AndroidHandler.RegisterStudentHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <SaveWork>(SaveWork.GetHeader(), SaveWorkHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <GetCourses>(GetCourses.GetHeader(), AndroidHandler.GetCoursesHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <GetCoursesDesktop>(GetCoursesDesktop.GetHeader(), GetCoursesHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <Pong>(Pong.GetHeader(), PongHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <EnrollStudent>(EnrollStudent.GetHeader(), EnrollStudentHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <StartEnrollment>(StartEnrollment.GetHeader(), AndroidHandler.StartEnrollmentHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <AddSchedule>(AddSchedule.GetHeader(), AndroidHandler.AddScheduleHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <CommitEnrollment>(CommitEnrollment.GetHeader(), AndroidHandler.CommitEnrollmentHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <StatusRequest>(StatusRequest.GetHeader(), AndroidHandler.StatusRequestHandler);
NetworkComms.AppendGlobalIncomingPacketHandler <CancelEnrollment>(CancelEnrollment.GetHeader(), AndroidHandler.CancelEnrollmentHandler);
// try
// {
Connection.StartListening(ConnectionType.UDP, new IPEndPoint(IPAddress.Any, 0), true);
// }
// catch (Exception e)
// {
//
// }
}
public async Task <IActionResult> EnrollStudent(EnrollStudent model)
{
var study = await studyDbService.GetByName(model.Studies);
if (study == null)
{
return(BadRequest($"Study with name: {model.Studies} not found"));
}
if (await studentDbService.Exists(model.IndexNumber))
{
return(BadRequest($"Student with index: {model.Studies} already exists"));
}
var enrollment = await enrollmentDbService.EnrollStudent(model, study);
return(StatusCode(201, enrollment));
}
// previously enrolled or not
public bool IsEnrolled(EnrollStudent enroll)
{
Connection.Open();
string query = "SELECT * FROM EnrollStudent WHERE StudentId = @studentId AND CourseId = @courseId AND Type = 'ENROLLED'";
Command = new SqlCommand(query, Connection);
Command.Parameters.AddWithValue("@studentId", enroll.StudentId);
Command.Parameters.AddWithValue("@courseId", enroll.CourseId);
Reader = Command.ExecuteReader();
bool isExists = Reader.HasRows;
Connection.Close();
return(isExists);
}
//public int Save(EnrollStudent enrollStudent)
//{
// EnrollStudentGateway enrollStudentGateway = new EnrollStudentGateway();
// return enrollStudentGateway.Save(enrollStudent);
//}
public string Save(EnrollStudent enrollStudent)
{
EnrollStudent aenrollStudent =
GetEnrollCourses.ToList()
.Find(
st =>
st.StudentId == enrollStudent.StudentId &&
st.CourseId == enrollStudent.CourseId);
if (aenrollStudent == null)
{
if (enrollStudentGateway.Save(enrollStudent) > 0)
{
return("Saved Sucessfully!");
}
return("Failed to save");
}
return("This course already taken by the student");
}
// ENROLL COURSE
public string EnrollCourse(EnrollStudent enroll)
{
if (studentGateway.IsEnrolled(enroll))
{
return("Exists");
}
else
{
int rowsAffected = studentGateway.EnrollCourse(enroll);
if (rowsAffected > 0)
{
return("Success");
}
else
{
return("Failed");
}
}
}
// enroll course to students
public int EnrollCourse(EnrollStudent enroll)
{
Connection.Open();
string query =
"INSERT INTO EnrollStudent VALUES (@studentId, @courseId, @date, @type)";
Command = new SqlCommand(query, Connection);
Command.Parameters.AddWithValue("@studentId", enroll.StudentId);
Command.Parameters.AddWithValue("@courseId", enroll.CourseId);
Command.Parameters.AddWithValue("@date", enroll.Date);
Command.Parameters.AddWithValue("@type", "ENROLLED");
int rowsAffected = Command.ExecuteNonQuery();
Connection.Close();
return(rowsAffected);
}
public async Task <EnrollmentDto> EnrollStudent(EnrollStudent model, StudyDto studyDto)
{
var transaction = await context.Database.BeginTransactionAsync();
try
{
var actualEnrollmentId = await ActualEnrollmentGetByName(model.Studies) ?? await EnrollmentCreate(studyDto.IdStudy);
await studentDbService.Create(model, actualEnrollmentId);;
await transaction.CommitAsync();
return(await GetById(actualEnrollmentId));
}
catch
{
await transaction.RollbackAsync();
throw;
}
}
public IActionResult EnrollStudent(EnrollStudent enrollStudent)
{
//Search for Studies Id
var studiesId = context.Studies.Where(s => s.Name == enrollStudent.StadiesName).Select(s1 => s1.IdStudy).FirstOrDefault();
//Checks if the Studies Name exists
if (studiesId == 0)
{
return(NotFound("Name of Study does not Exist!"));
}
//Search for IdEnrollment with the same Date, Semester and Studies name
int enrollExist = 0;
enrollExist = context.Enrollment.Where(enroll => enroll.StartDate == DateTime.Today &&
enroll.IdStudy == studiesId &&
enroll.Semester == enrollStudent.Semester
).Select(e => e.IdEnrollment).FirstOrDefault();
//if record exists - assign new Enrollment as old one (that exists)
if (enrollExist != 0)
{
newEnroll = context.Enrollment.Where(e => e.IdEnrollment == enrollExist).First();
}
else
{
//create new Endrollment
if (context.Enrollment.Where(e => e.IdEnrollment > 0).Count() == 0)
{
newEnroll.IdEnrollment = 1;
}
else
{
newEnroll.IdEnrollment = context.Enrollment.Max(e => e.IdEnrollment) + 1;
}
newEnroll.Semester = enrollStudent.Semester;
newEnroll.IdStudy = studiesId;
newEnroll.StartDate = DateTime.Now;
}
//Search for the dame indexNumber
int indexNumberExist = context.Student.Where(s => s.IndexNumber == enrollStudent.IndexNumber).Count();
if (indexNumberExist > 0)
{
return(BadRequest("Try to enter enother IndexNumber for this student!\n" +
$"The last enrolled student has IndexNumber : {context.Student.OrderBy(s1 => s1.IndexNumber).Select(s => s.IndexNumber).Last().ToString()}"));
}
newStudent.IndexNumber = enrollStudent.IndexNumber;
newStudent.FirstName = enrollStudent.FirstName;
newStudent.LastName = enrollStudent.LastName;
newStudent.BirthDate = enrollStudent.BirthDate;
newStudent.IdEnrollment = newEnroll.IdEnrollment;
//context.Enrollment.Add(newEnroll);
newStudent.IdEnrollmentNavigation = newEnroll;
//Checks if such a Student exists
string studentExist = context.Student.Where(s => s.FirstName == newStudent.FirstName &&
s.LastName == newStudent.LastName &&
s.BirthDate == newStudent.BirthDate).Select(s1 => s1.IndexNumber).FirstOrDefault();
//Adds new Student to Db
if (studentExist == null)
{
context.Student.Add(newStudent);
context.SaveChanges();
}
else
{
return(BadRequest($"This Student already exists INdexNumber : {studentExist}"));
}
return(Ok($"A new Student has been added IndexNUmber : {newStudent.IndexNumber}"));
}
public IActionResult InrollStudent(EnrollStudent enroll)
{
return(_service.EnrollStudent(enroll));
}
public ActionResult EnrollStudent(EnrollStudent enrollStudent)
{
string message = studentManager.EnrollStudent(enrollStudent);
return(Json(message, JsonRequestBehavior.AllowGet));
}
private static async void EnrollStudentHandler(PacketHeader packetheader, Connection connection, EnrollStudent req)
{
var ip = ((IPEndPoint)connection.ConnectionInfo.RemoteEndPoint).Address.ToString();
var client = Client.Cache.FirstOrDefault(x => x.IP == ip);
//Maybe do not ignore this on production
if (client == null)
{
return;
}
if (Models.Student.Cache.Any(x => x.StudentId.ToLower() == req.Student.StudentId.ToLower()))
{
await new EnrollStudentResult()
{
Success = false,
ErrorMessage = "Student ID Taken"
}.Send(new IPEndPoint(IPAddress.Parse(client.IP), client.Port));
return;
}
var stud = new Models.Student()
{
StudentId = req.Student.StudentId,
Address = req.Student.Address,
BirthDate = req.Student.BirthDate,
CourseId = req.Student.CourseId,
FirstName = req.Student.FirstName,
LastName = req.Student.LastName,
Major = req.Student.Major,
Minor = req.Student.Minor,
Scholarship = req.Student.Scholarship,
};
stud.Save();
await new EnrollStudentResult()
{
Success = true,
Id = stud.Id
}.Send(new IPEndPoint(IPAddress.Parse(client.IP), client.Port));
}
public IActionResult AddEnrollment(EnrollStudent request)
{
using (var connection = new SqlConnection(@"Data Source=db-mssql;Initial Catalog=s19200;Integrated Security=True"))
{
using (var command = new SqlCommand())
{
command.Connection = connection;
var transaction = connection.BeginTransaction();
connection.Open();
//checking if all the data is provided
if ((request.IndexNumber.ToString() == null) || (request.FirstName == null) || (request.LastName == null) || (request.Studies.ToString() == null))
{
return(BadRequest(400));
}
//checking if Studies are valid
command.CommandText = "select 1 from Studies where idStudy = @idStudy";
command.Parameters.AddWithValue("idStudy", request.Studies);
var rd = command.ExecuteReader();
if (!rd.Read())
{
return(BadRequest("Invalid Studies value"));
}
int idStudy = (int)rd["IdStudy"];
rd.Close();
command.CommandText = "select MAX(idEnrollment) as maximalID from Enrollment where Semester=1 IdStudy=@idStudy";
command.Parameters.AddWithValue("IdStudy", request.Studies);
var rd1 = command.ExecuteReader();
var maxId = (int)rd1["maximalID"];
rd1.Close();
command.CommandText = "insert into Enrollment(idEnrollment, Semester, idStudy, StartDate) values (@idEnrollment, @Semester, @IDStudy, @StartDate)";
command.Parameters.AddWithValue("idEnrollment", maxId + 1);
command.Parameters.AddWithValue("Semester", 1);
command.Parameters.AddWithValue("IDStudy", request.Studies);
command.Parameters.AddWithValue("StartDate", DateTime.Now.ToString());
var rd2 = command.ExecuteReader();
rd2.Close();
command.CommandText = "select * from Student where IndexNumber = @IndexNumber";
command.Parameters.AddWithValue("IndexNumber", request.IndexNumber);
var rd3 = command.ExecuteReader();
if (!rd3.Read())
{
rd3.Close();
command.CommandText = "insert into Student(IndexNumber, FirstName, LastName, BirthDate, idEnrollment) values @IndexNumber, @FirstName, @LastName, @BirthDate, @idEnrollment";
command.Parameters.AddWithValue("IndexNumber", request.IndexNumber);
command.Parameters.AddWithValue("FirstName", request.FirstName);
command.Parameters.AddWithValue("LastName", request.LastName);
command.Parameters.AddWithValue("BirthDate", request.BirthDate.ToString());
command.Parameters.AddWithValue("idEnrollment", maxId + 1);
var rd4 = command.ExecuteReader();
rd4.Close();
}
else
{
return(BadRequest("a student with given id already exists"));
}
transaction.Commit();
var response = new EnrollStudentResponse
{
FirstName = request.FirstName,
LastName = request.LastName,
IndexNumber = request.IndexNumber
};
return(Ok(response));
}
}
}
