public HttpResponseMessage CreateStudentTest([FromBody] StudentTest studentTest)
{
using (var connection = new SqlConnection(ConnectionString))
{
SqlCommand sqlCmd = new SqlCommand("INSERT INTO Student.StudentTest VALUES(@TestID, @StudentID)", connection);
sqlCmd.Parameters.AddWithValue("TestID", studentTest.TestID);
sqlCmd.Parameters.AddWithValue("StudentID", studentTest.StudentID);
try
{
connection.Open();
int i = sqlCmd.ExecuteNonQuery();
SqlCommand sqlStudentTest = new SqlCommand("SELECT TOP 1 * FROM Student.StudentTest ORDER BY StudentTestID DESC", connection);
StudentTest last = new StudentTest();
using (SqlDataReader studentTestRead = sqlStudentTest.ExecuteReader())
{
while (studentTestRead.Read())
{
last.StudentTestID = Convert.ToInt32(studentTestRead["StudentTestID"]);
last.TestID = Convert.ToInt32(studentTestRead["TestID"]);
last.StudentID = Convert.ToInt32(studentTestRead["StudentID"]);
}
}
var response = Request.CreateResponse(HttpStatusCode.Created, last);
response.Headers.Location = new Uri(Request.RequestUri + "/" + last.TestID);
return(response);
}
catch (Exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Error 404 Bad request"));
}
}
}
public void PublishTest(List <int> classrooms, int idTest)
{
try
{
foreach (int idClass in classrooms)
{
var idClassExits = context.ClassroomTest.Where(c => c.IdTest == idTest && c.IdClassroom == idClass).FirstOrDefault();
if (idClassExits == null)
{
foreach (User s in context.User)
{
if (s.IdClassroom == idClass)
{
StudentTest student = new StudentTest();
student.IdUser = s.Id;
student.IdTest = idTest;
student.Grade = 0;
student.IsDone = false;
context.StudentTest.Add(student);
}
}
ClassroomTest classroomTest = new ClassroomTest();
classroomTest.IdClassroom = idClass;
classroomTest.IdTest = idTest;
context.ClassroomTest.Add(classroomTest);
}
}
context.SaveChanges();
}
catch (Exception ex)
{
Console.WriteLine("Error: ", ex.Message);
}
}
public HttpResponseMessage GetStudentTest()
{
List <StudentTest> result = new List <StudentTest>();
using (var connection = new SqlConnection(ConnectionString))
{
SqlCommand sqlCmd = new SqlCommand("select * from Student.StudentTest", connection)
{
CommandType = CommandType.Text
};
try
{
connection.Open();
using (SqlDataReader dataReader = sqlCmd.ExecuteReader())
{
while (dataReader.Read())
{
var studentTest = new StudentTest
{
StudentTestID = Convert.ToInt32(dataReader["StudentTestID"]),
TestID = Convert.ToInt32(dataReader["TestID"]),
StudentID = Convert.ToInt32(dataReader["StudentID"])
};
result.Add(studentTest);
}
}
}
catch (Exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Error retrieving data"));
}
}
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
public HttpResponseMessage UpdateStudentTest([FromBody] StudentTest studentTest)
{
using (var connection = new SqlConnection(ConnectionString))
{
try
{
using (var sqlCmd = new SqlCommand("UPDATE Student.StudentTest SET TestID=@TestID, StudentID=@StudentID WHERE StudentTestID=@id"))
{
connection.Open();
sqlCmd.Connection = connection;
sqlCmd.Parameters.AddWithValue("TestID", studentTest.TestID);
sqlCmd.Parameters.AddWithValue("StudentID", studentTest.StudentID);
sqlCmd.Parameters.AddWithValue("id", studentTest.StudentTestID);
int rowAffected = sqlCmd.ExecuteNonQuery();
if (rowAffected == 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Error 404 Not Found"));
}
}
}
catch (Exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Error 400 Bad Request"));
}
}
return(Request.CreateResponse(HttpStatusCode.OK, "Updated Successfully"));
}
public JsonResult CreateOrEdit(StudentTest input, bool isEdit, bool isSendMail)
{
try
{
if (!isEdit)
{
return(Json(new { status = false, mess = "Có lỗi xảy ra: " }));
}
using (var workScope = new UnitOfWork(new ELearningDBContext()))
{
var elm = workScope.StudentTests.Get(input.Id);
if (elm != null) //update
{
elm.Point = input.Point;
elm.ReplyFile = input.ReplyFile;
if (isSendMail)
{
var lecture = workScope.Lectures.FirstOrDefault(x => x.Id == input.LectureId);
var client = new SmtpClient
{
Host = "smtp.gmail.com",
Port = 587,
UseDefaultCredentials = false,
DeliveryMethod = SmtpDeliveryMethod.Network,
Credentials =
new NetworkCredential(
"*****@*****.**",
"@Vat883279"),
EnableSsl = true,
};
var from = new MailAddress("*****@*****.**", "Admin Elearning");
var to = new MailAddress(input.Email);
var mail = new MailMessage(from, to)
{
Subject = "Điểm môn học!",
Body = "Xin chào " + "<span style='color: red;'>" + input.Username + "</span>" + "!" + "<br/> Điểm bài học " + lecture.Name + " của bạn là: " + input.Point,
IsBodyHtml = true,
};
Attachment data = new Attachment(
Server.MapPath("~/" + input.ReplyFile),
MediaTypeNames.Application.Octet);
// your path may look like Server.MapPath("~/file.ABC")
mail.Attachments.Add(data);
client.Send(mail);
}
workScope.StudentTests.Put(elm, elm.Id);
workScope.Complete();
return(Json(new { status = true, mess = "Cập nhập thành công" }));
}
else
{
return(Json(new { status = false, mess = "Không tồn tại " + keyElement }));
}
}
}
catch (Exception ex)
{
return(Json(new { status = false, mess = "Có lỗi xảy ra: " + ex.Message }));
}
}
public void If_Five_Elements_Inserted_Into_BiTree_In_Alphabetic_Order()
{
StudentTest st1 = new StudentTest { FirstName = "Артем", LastName = "Зозуля", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 82 };
StudentTest st2 = new StudentTest { FirstName = "Семен", LastName = "Кириллов", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 71 };
StudentTest st3 = new StudentTest { FirstName = "Игорь", LastName = "Маликов", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 78 };
StudentTest st4 = new StudentTest { FirstName = "Виталий", LastName = "Таськов", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 74 };
StudentTest st5 = new StudentTest { FirstName = "Семен", LastName = "Доброштан", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 84 };
BiTree<StudentTest> tree = new BiTree<StudentTest>();
StudentTest[] studentsArray = new StudentTest[5];
int count = 0;
tree.Insert(st1);
tree.Insert(st2);
tree.Insert(st3);
tree.Insert(st4);
tree.Insert(st5);
foreach (var student in tree)
{
studentsArray[count] = student;
count++;
}
for (int i = 0; i < studentsArray.Length-1; i++)
{
Assert.IsTrue((studentsArray[i+1].CompareTo(studentsArray[i])>=0),"Elements not in alphabetic order. Method result: " + studentsArray[i + 1].LastName + " >= " + studentsArray[i].LastName);
}
}
public JsonResult GetStudentDetils(string registrationNo)
{
StudentTest student = aStudentManager.GetStudentInfo(registrationNo);
TempData["dpt"] = student.DepartmentId;
return(Json(student));
}
public StudentTest GetStudentInfo(string regNo)
{
StudentTest aStudentTest = aStudentResultGateWay.GetStudentInfo(regNo);
aStudentTest.DeptName = aStudentResultGateWay.GetDepartmentName(aStudentTest.DepartmentId);
return(aStudentTest);
}
public void ProcessAnswers(Dictionary <int, int> questionAndAnswersIds, StudentTest studentTest)
{
//First we have to add to database studentTest and the we have to add StudentTestAsnwer
this.dbContext.StudentTests.Add(studentTest);
this.dbContext.SaveChanges();
var studentTestId = studentTest.Id;
foreach (var questionAnswerId in questionAndAnswersIds)
{
var questionId = questionAnswerId.Key;
var answerId = questionAnswerId.Value;
var answer = this.dbContext.Answers.FirstOrDefault(x => x.Id == answerId);
StudentTestAsnwer student = new StudentTestAsnwer()
{
QuestionId = questionAnswerId.Key,
AnswerId = questionAnswerId.Value,
StudentTestId = studentTestId,
};
if (answer.IsRightAnswer)
{
student.GainedAnswers = answer.Question.Points;
}
this.dbContext.StudentTestAsnwers.Add(student);
}
this.dbContext.SaveChanges();
}
static void Main(string[] args)
{
Program prog = new Program();
/*BiTree<int> tree3 = new BiTree<int>();
tree3.Insert(6);*/
StudentTest st1 = new StudentTest { FirstName = "Артем", LastName = "Зозуля", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 82 };
StudentTest st2 = new StudentTest { FirstName = "Семен", LastName = "Кириллов", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 71 };
StudentTest st3 = new StudentTest { FirstName = "Игорь", LastName = "Маликов", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 78 };
StudentTest st4 = new StudentTest { FirstName = "Виталий", LastName = "Таськов", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 74 };
StudentTest st5 = new StudentTest { FirstName = "Семен", LastName = "Доброштан", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 84 };
//BiTree<StudentTest> tree = new BiTree<StudentTest>(new StudentTestByTestTitleComparator());
BiTree<StudentTest> tree = new BiTree<StudentTest>();
tree.ItemRemoved += prog.Tree_ItemRemoved;
tree.Insert(st1);
tree.Insert(st2);
tree.Insert(st3);
tree.Insert(st4);
tree.Insert(st5);
foreach (var item in tree)
{
Console.WriteLine(item.LastName);
}
Console.WriteLine("Дерево содержит элементов: " + tree.GetTreeCount);
Console.WriteLine("-----------------");
tree.Remove(st2);
Console.WriteLine("-----------------");
foreach (var item in tree)
{
Console.WriteLine(item.LastName);
}
Console.WriteLine("Дерево содержит элементов: " + tree.GetTreeCount);
try
{
BiTree<int> tree2 = new BiTree<int>();
Console.WriteLine("Value type поиск-----------------");
Console.WriteLine(tree2.Search(2));
tree2.Insert(2);
Console.WriteLine("Value type поиск-----------------");
Console.WriteLine(tree2.Search(2).GetValue);
tree2.Insert(12);
tree2.Insert(8);
tree2.Insert(15);
tree2.Insert(4);
Console.WriteLine("Value type -----------------");
foreach (var item in tree2)
{
Console.WriteLine(item);
}
}
catch (NotImplementedException notImplEx)
{
Console.WriteLine(notImplEx.Message);
}
Console.ReadKey();
}
public static void Remove()
{
Console.Clear();
Console.Write("Input Student Name: ");//Only name just for example
string stName = Console.ReadLine();
StudentTest value = binaryTree.Where(st => st.StudentName == stName).FirstOrDefault();
binaryTree.Remove(value);
}
private List <StudentTest> AddStudentTest()
{
List <StudentTest> lxStudentTest = new List <StudentTest>();
StudentTest xStudentTest = new StudentTest()
{
StudentRefFk = 1,
TestRefFk = 1,
WritenTime = 10,
IsTestDone = true,
Score = 2,
ID = 1,
};
StudentTest xStudentTest2 = new StudentTest()
{
StudentRefFk = 2,
TestRefFk = 1,
WritenTime = 0,
IsTestDone = false,
Score = 0,
ID = 2,
};
StudentTest xStudentTest3 = new StudentTest()
{
StudentRefFk = 3,
TestRefFk = 1,
WritenTime = 0,
IsTestDone = false,
Score = 0,
ID = 3,
};
StudentTest xStudentTest4 = new StudentTest()
{
StudentRefFk = 1,
TestRefFk = 2,
WritenTime = 0,
IsTestDone = false,
Score = 0,
ID = 4,
};
StudentTest xStudentTest5 = new StudentTest()
{
StudentRefFk = 2,
TestRefFk = 2,
WritenTime = 0,
IsTestDone = false,
Score = 0,
ID = 5,
};
lxStudentTest.Add(xStudentTest);
lxStudentTest.Add(xStudentTest2);
lxStudentTest.Add(xStudentTest3);
lxStudentTest.Add(xStudentTest4);
lxStudentTest.Add(xStudentTest5);
return(lxStudentTest);
}
static void Main(string[] args)
{
//SimpleTest.Test();
//ReadMethodTest.Test();
//CommandTest.Test();
//OtherTest.Test2();
//StudentTest.Test();
StudentTest.Test2();
Console.ReadLine();
}
public void If_InsertMethod_Increases_BiTree_Count()
{
StudentTest st1 = new StudentTest { FirstName = "Артем", LastName = "Зозуля", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 82 };
BiTree<StudentTest> tree = new BiTree<StudentTest>();
int expectedCount = 1;
tree.Insert(st1);
Assert.AreEqual(expectedCount, tree.GetTreeCount);
}
static void Main()
{
StringBuilderTests.StartTest();
Console.WriteLine();
EnumerableTest.StartTest();
Console.WriteLine();
StudentTest.StartTest();
Console.WriteLine();
TimerAndEventTest.StartTest();
}
//public static void Clear()
//{
// foreach (var item in binaryTree)
// {
// binaryTree.Remove(item);
// }
//}
public static void Add()
{
Console.Clear();
Console.Write("Input Student Name: ");
string stName = Console.ReadLine();
Console.Write("Input Test Name: ");
string testName = Console.ReadLine();
Console.Write("Input Rating: ");
int rating = Int32.Parse(Console.ReadLine());
StudentTest value = new StudentTest(stName, testName, rating, DateTime.Now);
binaryTree.Insert(value);
}
internal int GetTestInfoTime(Student xStudent, Test xText)
{
StudentTest xTest = new StudentTest();
using (var db = new DbModel())
{
var querry = from Time in db.StudentTests
where Time.StudentRefFk == xStudent.ID
where Time.TestRefFk == xText.ID
select Time;
foreach (var item in querry)
{
xTest = item;
}
}
return(xTest.WritenTime);
}
public async Task <bool> UpdateStudentTest(int idStudentTest, StudentTest studentTest)
{
try
{
var oldStudentTest = context.StudentTest.Where(st => st.Id == idStudentTest).FirstOrDefault();
if (oldStudentTest != null)
{
oldStudentTest.IdUser = studentTest.IdUser;
oldStudentTest.IdTest = studentTest.IdTest;
}
return(await context.SaveChangesAsync() > 0);
}
catch (Exception ex)
{
Console.WriteLine("Error: ", ex.Message);
return(false);
}
}
/// <summary>
/// updates the test,deletes the old one and puts t instead
/// </summary>
/// <param name="t">the updated test</param>
/// <param name="tl">test in the list</param>
public void UpdateTest(Test t)
{
foreach (Test tl in DS.DataSource.testList)
{
if (t.NumOfTest == tl.NumOfTest)
{
DS.DataSource.testList.Remove(tl);
DS.DataSource.testList.Add(t);
Tester tester = (Tester)(from item in DS.DataSource.testerList
where item.TesterId == t.TesterId
select item).FirstOrDefault();
(tester).TesterWorkHours[(int)(t.Datetime.DayOfWeek), (t.Hour - 9)] = false;
UpdateTester(tester);
Trainee trainee = (Trainee)(from item in DS.DataSource.traineeList
where item.TraineeId == t.TraineeId
select item).FirstOrDefault();
StudentTest tryTest = new StudentTest {
GetDate = t.Datetime, GetHour = t.Hour
};
if (tryTest.IsBigger((trainee).TraineeTest))
{
(trainee).TraineeTest = new StudentTest {
GetDate = t.Datetime, GetHour = t.Hour
};
(trainee).TraineeAmountOfTests++;
(trainee).TraineeGrade = t.Grade;
UpdateTrainee(trainee);
return;
}
if (tryTest.IsEqual(((Trainee)trainee).TraineeTest))
{
throw new Exception("The test's time is equal so it shall not be changed");
}
else
{
if ((tryTest.GetDate < DateTime.Now) || (tryTest.GetDate == DateTime.Now && tryTest.GetHour < (int)(DateTime.Now.Hour)))//if the new date of the test already occurred the time will not be changed
{
throw new Exception("The test's time has been already, you can't take a test in the past");
}
}
}
}
}
public IActionResult AddStudent()
{
try
{
StudentTest studentTest = new StudentTest()
{
Id = Guid.NewGuid().ToString(), Age = 10, Gender = "boy", Name = "张三"
};
_studentTestService.Add(studentTest);
int num = _unitOfWork.Commit();
_logger.LogInformation($"添加{num}条数据");
return(Ok());
}
catch (Exception ex)
{
throw ex;
}
}
public void If_SearchMethod_Searches_Correct_Node()
{
StudentTest st1 = new StudentTest { FirstName = "Артем", LastName = "Зозуля", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 82 };
StudentTest st2 = new StudentTest { FirstName = "Семен", LastName = "Кириллов", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 71 };
StudentTest st3 = new StudentTest { FirstName = "Игорь", LastName = "Маликов", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 78 };
StudentTest st4 = new StudentTest { FirstName = "Виталий", LastName = "Таськов", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 74 };
StudentTest st5 = new StudentTest { FirstName = "Семен", LastName = "Доброштан", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 84 };
BiTree<StudentTest> tree = new BiTree<StudentTest>();
tree.Insert(st1);
tree.Insert(st2);
tree.Insert(st3);
tree.Insert(st4);
tree.Insert(st5);
TreeNode<StudentTest> node = tree.Search(st3);
StudentTest expectedSt = node.GetValue;
Assert.IsTrue(expectedSt.CompareTo(st3) == 0);
}
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken)
{
var studentTest = new StudentTest
{
Id = request.Id,
codeId = request.codeId,
levelTestId = request.levelTestId,
studentId = request.studentId
};
_context.StudentTest.Add(studentTest);
var success = await _context.SaveChangesAsync() > 0;
if (success)
{
return(Unit.Value);
}
throw new Exception("Problem saving changes");
}
public int GetTestInfoScore(Student xStudent, Test xText)
{
StudentTest xTest = new StudentTest();
using (var db = new DbModel())
{
Console.WriteLine(xStudent.ID + " STUDENT ID " + xTest.ID + " TEST ID");
var querry = from qTime in db.StudentTests
where qTime.StudentRefFk == xStudent.ID
where qTime.TestRefFk == xText.ID
select qTime;
foreach (var item in querry)
{
xTest = item;
}
}
return(xTest.Score);
}
public StudentTest GetStudentInfo(string regisNo)
{
Query = "Select * From Student where RegistrationNo=@regno";
Command = new SqlCommand(Query, Connection);
Connection.Open();
Command.Parameters.Clear();
Command.Parameters.Add("regno", SqlDbType.VarChar);
Command.Parameters["regno"].Value = regisNo;
Reader = Command.ExecuteReader();
StudentTest aStudent = new StudentTest();
// List<Student> students = new List<Student>();
if (Reader.Read())
{
aStudent.Name = Reader["Name"].ToString();
aStudent.Email = Reader["Email"].ToString();
aStudent.DepartmentId = (int)Reader["DepartmentId"];
}
Connection.Close();
return(aStudent);
}
public int GetStudentTestID(int p_iStudentID, int p_iTestID)
{
StudentTest xStudentTest = new StudentTest();
using (var db = new Model1())
{
var querry = from StudentTest in db.StudentTests
join xTest in db.Tests on StudentTest.TestRefFk equals xTest.ID into GroupT
join xStuden in db.Students on StudentTest.StudentRefFk equals xStuden.ID into Group
from xGroup in Group
where xGroup.ID == p_iStudentID
from xGroupT in GroupT
where xGroupT.ID == p_iTestID
select StudentTest;
foreach (var item in querry)
{
xStudentTest = item;
}
}
return(xStudentTest.ID);
}
/// <summary>
/// updates the test,deletes the old one and puts t instead
/// </summary>
/// <param name="t">the updated test</param>
/// <param name="tl">test in the list</param>
public void UpdateTest(Test t)
{
foreach (Test tl in DS.DataSource.testList)
{
if (t.NumOfTest == tl.NumOfTest)
{
DS.DataSource.testList.Remove(tl);
DS.DataSource.testList.Add(t);
var v = from item in DS.DataSource.testerList
where item.testerId == t.TesterId
select item;
((Tester)v).testerWorkHours[(int)(t.Datetime.DayOfWeek), (t.Hour - 9)] = true;
UpdateTester((Tester)v);
var temp = from item in DS.DataSource.traineeList
where item.traineeId == t.TraineeId
select item;
StudentTest tryTest = new StudentTest(t.Datetime, t.Hour);
if (tryTest.IsBigger(((Trainee)temp).TraineeTest))
{
((Trainee)temp).TraineeTest = new StudentTest(t.Datetime, t.Hour);
((Trainee)temp).TraineeAmountOfTests++;
UpdateTrainee((Trainee)temp);
return;
}
if (tryTest.IsEqual(((Trainee)temp).TraineeTest))
{
throw new Exception("The test's time is equal so it shall not be changed");
}
else
{
if ((tryTest.GetDate() < DateTime.Now) || (tryTest.GetDate() == DateTime.Now && tryTest.GetHour() < (int)(DateTime.Now.Hour)))//if the new date of the test already occurred the time will not be changed
{
throw new Exception("The test's time has been already, you can't take a test in the past");
}
}
}
}
}
public HttpResponseMessage GetByID(int id)
{
StudentTest studentTest = null;
using (var connection = new SqlConnection(ConnectionString))
{
SqlCommand sqlCmd = new SqlCommand("select * from Student.StudentTest where StudentTestID=" + id, connection)
{
CommandType = CommandType.Text
};
try
{
connection.Open();
using (SqlDataReader dataReader = sqlCmd.ExecuteReader())
{
while (dataReader.Read())
{
studentTest = new StudentTest
{
StudentTestID = Convert.ToInt32(dataReader["StudentTestID"]),
TestID = Convert.ToInt32(dataReader["TestID"]),
StudentID = Convert.ToInt32(dataReader["StudentID"])
};
}
}
if (studentTest == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Error 404 Found"));
}
}
catch (Exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Error retrieving data"));
}
}
return(Request.CreateResponse(HttpStatusCode.OK, studentTest));
}
public async Task <IEnumerable <StudentTest> > CreateStudentTestsListForUserAsync(User user)
{
var testResultsForThisStudent = await _unitOfWork.TestResultRepository
.GetAllAsync(testResult => testResult.StudentUser == user);
IEnumerable <StudentTest> studentTests = new List <StudentTest>();
var allTestBases = await _unitOfWork.TestBaseRepository
.GetAllAsync(null, null, new[] { "Topic", "Topic.Subject" });
foreach (var testBase in allTestBases)
{
var testResultsForThisTest = testResultsForThisStudent
.Where(x => x.TestBaseId == testBase.Id);
int numOfTriesLeft = testBase.NumOfTries - testResultsForThisTest.Count();
var isPassed = testResultsForThisTest.Any();
var studentTest = new StudentTest(testBase, numOfTriesLeft, isPassed);
studentTests = studentTests.Append(studentTest);
}
return(studentTests);
}
static void Main(string[] args)
{
StudentTest.Testing();
}
public async Task <IActionResult> UpdateStudentTest(int id, [FromBody] StudentTest studentTest)
{
var updatedStudentTest = await _service.UpdateStudentTest(id, studentTest);
return(Json(new { success = updatedStudentTest }));
}
private void SendTestToAdmin(Test test, string text, DatePicker datePickerEndDate, DatePicker datePickerStartDate, List <Student> students)
{
ClearWarning();
if (listViewTestToSend.SelectedItem != null &&
CheckTimeInput(text) == true &&
CheckDates(DateTime.Now, datePickerStartDate.SelectedDate) &&
CheckDates(datePickerStartDate.SelectedDate, datePickerEndDate.SelectedDate) &&
students.Count >= 1)
{
using (var db = new DbModel())
{
var query = from t in db.Tests
where t.ID == test.ID
select t;
foreach (var item in query.ToList())
{
item.TimeStampe = int.Parse(txtBoxTimeInput.Text);
item.StartDate = DatePickerStartDate.SelectedDate;
item.EndDate = DatePickerEndDate.SelectedDate;
var query2 = from t in db.Users
where t.OccupationFk == 2
select t;
foreach (var item2 in query2.ToList())
{
UserTest toAdmin = new UserTest();
toAdmin.TestFk = item.ID;
toAdmin.UserFk = item2.ID;
db.UserTests.Add(toAdmin);
}
}
foreach (var item in students)
{
StudentTest newTest = new StudentTest();
newTest.TestRefFk = test.ID;
newTest.StudentRefFk = item.ID;
newTest.IsChecked = false;
db.StudentTests.Add(newTest);
}
//var teacherUserTest = from u in db.UserTests
// where u.UserFk == theTeacher.ID
// select u;
//foreach (var item in teacherUserTest.ToList())
//{
// db.UserTests.Remove(item);
//}
MessageBox.Show("Provet har skickats till Admin");
UpdateList();
ClearSelection();
db.SaveChanges();
}
}
else
{
if (students.Count < 1)
{
lblWarning.Content += "Välj studenter som skall göra provet";
}
}
}
public static void Main(string[] args)
{
// ext methods
//var myEnum = new List<int>();
//for (int i = 0; i < 30; i++)
//{
// myEnum.Add(i);
//}
//var s = myEnum.ToStringExtensions();
//Console.WriteLine(s);
// delegates
//var testString = "test bzzstring";
//StringDelagate exampleDelagate = new DelagateTest().StringFunction;
// does not work - cannot pass a function to a function
//string z = new DelagateTest().StringFunction(DelagateTest().StringFunction(testString));
// works - pass a function as delagate to a function
//string z = new DelagateTest().StringFunction(exampleDelagate(testString));
// works - use predefined delagate that takes 1-16 TArgs and returns TResult
//Func<string,string> predfinedString = new DelagateTest().StringFunction;
//string z = predfinedString(testString);
//Console.WriteLine(z);
var currentStudents = new StudentTest().AddStudents();
// only students which FirstName is before LastName
var sortedStudentsByName = currentStudents.Where(student =>
String.Compare(student.FirstName, student.LastName) < 0);
//foreach (var student in sortedStudentsByName)
//{
// Console.WriteLine(student);
//}
// only students with Age < 25
var sortedStudentsByAge = currentStudents.Where(student =>
student.Age < 25);
//foreach (var student in sortedStudentsByAge)
//{
// Console.WriteLine(student);
//}
// sort students by by first name and then by last name in descending order
var sortedStudentsByNameDescending = currentStudents
.OrderByDescending(student => student.FirstName)
.ThenByDescending(student => student.LastName);
//foreach (var student in sortedStudentsByNameDescending)
//{
// Console.WriteLine(student);
//}
// Extract elements from a list only if they are divisible by 7 and 3
var testList = new List <int>();
for (int i = 0; i < 2000; i++)
{
testList.Add(i);
}
var extractedList = testList.Where(i => i % 3 == 0 && i % 7 == 0);
foreach (var num in extractedList)
{
Console.WriteLine(num);
}
}
private static void Main()
//****************************************************************************80
//
// Purpose:
//
// test_values_test() tests test_values().
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 04 January 2019
//
// Author:
//
// John Burkardt
//
{
Console.WriteLine("");
Console.WriteLine("test_values_test():");
Console.WriteLine(" Test test_values().");
AbramsTest.abram0_values_test();
AbramsTest.abram1_values_test();
AbramsTest.abram2_values_test();
AGMTest.agm_values_test();
AiryTest.airy_ai_values_test();
AiryTest.airy_ai_int_values_test();
AiryTest.airy_ai_prime_values_test();
AiryTest.airy_bi_values_test();
AiryTest.airy_bi_int_values_test();
AiryTest.airy_bi_prime_values_test();
AiryTest.airy_cai_values_test();
AiryTest.airy_cbi_values_test();
AiryTest.airy_gi_values_test();
AiryTest.airy_hi_values_test();
ArcTest.arccos_values_test();
ArcTest.arccosh_values_test();
ArcTest.arcsin_values_test();
ArcTest.arcsinh_values_test();
ArcTest.arctan_values_test();
ArcTest.arctan_int_values_test();
ArcTest.arctanh_values_test();
BeiBellTest.bei0_values_test();
BeiBellTest.bei1_values_test();
BeiBellTest.bell_values_test();
BerTest.ber0_values_test();
BerTest.ber1_values_test();
BernoulliTest.bernoulli_number_values_test();
BernoulliTest.bernoulli_poly_values_test();
BernsteinTest.bernstein_poly_01_values_test();
BesselTest.bessel_i0_values_test();
BesselTest.bessel_i0_int_values_test();
BesselTest.bessel_i0_spherical_values_test();
BesselTest.bessel_i1_values_test();
BesselTest.bessel_i1_spherical_values_test();
BesselTest.bessel_in_values_test();
BesselTest.bessel_ix_values_test();
BesselTest.bessel_j_spherical_values_test();
BesselTest.bessel_j0_values_test();
BesselTest.bessel_j0_int_values_test();
BesselTest.bessel_j0_spherical_values_test();
BesselTest.bessel_j0_zero_values_test();
BesselTest.bessel_j1_values_test();
BesselTest.bessel_j1_spherical_values_test();
BesselTest.bessel_jn_values_test();
BesselTest.bessel_jx_values_test();
BesselTest.bessel_k0_values_test();
BesselTest.bessel_k0_int_values_test();
BesselTest.bessel_k1_values_test();
BesselTest.bessel_kn_values_test();
BesselTest.bessel_kx_values_test();
BesselTest.bessel_y0_values_test();
BesselTest.bessel_y0_int_values_test();
BesselTest.bessel_y0_spherical_values_test();
BesselTest.bessel_y1_values_test();
BesselTest.bessel_y1_spherical_values_test();
BesselTest.bessel_yn_values_test();
BesselTest.bessel_yx_values_test();
BetaTest.beta_values_test();
BetaTest.beta_cdf_values_test();
BetaTest.beta_inc_values_test();
BetaTest.beta_log_values_test();
BetaTest.beta_noncentral_cdf_values_test();
BetaTest.beta_pdf_values_test();
BinomialTest.binomial_values_test();
BinomialTest.binomial_cdf_values_test();
BinomialTest.binomial_pdf_values_test();
BivariateTest.bivariate_normal_cdf_values_test();
ComplexTest.c8_log_values_test();
CatalanTest.catalan_values_test();
CauchyTest.cauchy_cdf_values_test();
CubeRootTest.cbrt_values_test();
ChebyshevTest.cheby_t_poly_values_test();
ChebyshevTest.cheby_t01_poly_values_test();
ChebyshevTest.cheby_u_poly_values_test();
ChebyshevTest.cheby_u01_poly_values_test();
ChebyshevTest.cheby_v_poly_values_test();
ChebyshevTest.cheby_v01_poly_values_test();
ChebyshevTest.cheby_w_poly_values_test();
ChebyshevTest.cheby_w01_poly_values_test();
ChiTest.chi_values_test();
ChiTest.chi_square_cdf_values_test();
ChiTest.chi_square_pdf_values_test();
ChiTest.chi_square_noncentral_cdf_values_test();
CosineTest.ci_values_test();
CosineTest.cin_values_test();
CosineTest.cinh_values_test();
ClausenTest.clausen_values_test();
ClebschGordanTest.clebsch_gordan_values_test();
CollatzTest.collatz_count_values_test();
CosineTest.cos_values_test();
CosineTest.cos_degree_values_test();
CosineTest.cos_power_int_values_test();
CosineTest.cosh_values_test();
CotTest.cot_values_test();
ConstPressureTest.cp_values_test();
DateTest.datenum_values_test();
DawsonTest.dawson_values_test();
DebyeTest.debye1_values_test();
DebyeTest.debye2_values_test();
DebyeTest.debye3_values_test();
DebyeTest.debye4_values_test();
DedekindTest.dedekind_sum_values_test();
DielectricTest.dielectric_values_test();
DilogarithmTest.dilogarithm_values_test();
ExpIntegralTest.e1_values_test();
DateTest.easter_gregorian_values_test();
DateTest.easter_julian_values_test();
ExpIntegralTest.ei_values_test();
EllipticTest.elliptic_ea_values_test();
EllipticTest.elliptic_ek_values_test();
EllipticTest.elliptic_em_values_test();
EllipticTest.elliptic_fa_values_test();
EllipticTest.elliptic_fk_values_test();
EllipticTest.elliptic_fm_values_test();
EllipticTest.elliptic_inc_ea_values_test();
EllipticTest.elliptic_inc_ek_values_test();
EllipticTest.elliptic_inc_em_values_test();
EllipticTest.elliptic_inc_fa_values_test();
EllipticTest.elliptic_inc_fk_values_test();
EllipticTest.elliptic_inc_fm_values_test();
EllipticTest.elliptic_inc_pia_values_test();
EllipticTest.elliptic_inc_pik_values_test();
EllipticTest.elliptic_inc_pim_values_test();
EllipticTest.elliptic_pia_values_test();
EllipticTest.elliptic_pik_values_test();
EllipticTest.elliptic_pim_values_test();
ErrorFuncTest.erf_values_test();
ErrorFuncTest.erfc_values_test();
EulerTest.euler_number_values_test();
EulerTest.euler_poly_values_test();
ExponentialTest.exp_values_test();
ExponentialTest.exp3_int_values_test();
ExponentialTest.exponential_01_pdf_values_test();
ExponentialTest.exponential_cdf_values_test();
ExponentialTest.exponential_pdf_values_test();
ExtremeTest.extreme_values_cdf_values_test();
FTest.f_cdf_values_test();
FTest.f_noncentral_cdf_values_test();
FresnelTest.fresnel_cos_values_test();
FresnelTest.fresnel_sin_values_test();
FrobeniusTest.frobenius_number_data_values_test();
FrobeniusTest.frobenius_number_order_values_test();
FrobeniusTest.frobenius_number_order2_values_test();
GammaTest.gamma_values_test();
GammaTest.gamma_01_pdf_values_test();
GammaTest.gamma_cdf_values_test();
GammaTest.gamma_inc_values_test();
GammaTest.gamma_inc_p_values_test();
GammaTest.gamma_inc_q_values_test();
GammaTest.gamma_inc_tricomi_values_test();
GammaTest.gamma_log_values_test();
GammaTest.gamma_pdf_values_test();
GegenbauerTest.gegenbauer_poly_values_test();
GeometricTest.geometric_cdf_values_test();
GoodwinTest.goodwin_values_test();
GudermannianTest.gud_values_test();
HermiteTest.hermite_function_values_test();
HermiteTest.hermite_poly_phys_values_test();
HermiteTest.hermite_poly_prob_values_test();
HyperTest.hyper_1f1_values_test();
HyperTest.hyper_2f1_values_test();
HyperTest.hypergeometric_cdf_values_test();
HyperTest.hypergeometric_pdf_values_test();
HyperTest.hypergeometric_u_values_test();
ITest.i0ml0_values_test();
ITest.i1ml1_values_test();
FactorialTest.i4_factorial_values_test();
FactorialTest.i4_factorial2_values_test();
FactorialTest.i4_fall_values_test();
FactorialTest.i4_rise_values_test();
IntgrTest.int_values_test();
ChiTest.inverse_chi_square_pdf_values_test();
GammaTest.inverse_gamma_pdf_values_test();
JacobiTest.jacobi_cn_values_test();
JacobiTest.jacobi_dn_values_test();
JacobiTest.jacobi_poly_values_test();
JacobiTest.jacobi_sn_values_test();
DateTest.jed_ce_values_test();
DateTest.jed_mjd_values_test();
DateTest.jed_rd_values_test();
DateTest.jed_weekday_values_test();
KelvinTest.kei0_values_test();
KelvinTest.kei1_values_test();
KelvinTest.ker0_values_test();
KelvinTest.ker1_values_test();
LaguerreTest.laguerre_associated_values_test();
LaguerreTest.laguerre_general_values_test();
LaguerreTest.laguerre_polynomial_values_test();
LambertTest.lambert_w_values_test();
LaplaceTest.laplace_cdf_values_test();
LegendreTest.legendre_associated_values_test();
LegendreTest.legendre_associated_normalized_values_test();
LegendreTest.legendre_associated_normalized_sphere_values_test();
LegendreTest.legendre_function_q_values_test();
LegendreTest.legendre_normalized_polynomial_values_test();
LegendreTest.legendre_polynomial_values_test();
LegendreTest.legendre_shifted_polynomial_values_test();
LerchTest.lerch_values_test();
LobachevskyTest.lobachevsky_values_test();
LobattoTest.lobatto_polynomial_values_test();
LobattoTest.lobatto_polynomial_derivatives_test();
LogarithmTest.log_values_test();
LogarithmTest.log_normal_cdf_values_test();
LogarithmTest.log_series_cdf_values_test();
LogarithmTest.log10_values_test();
LogarithmTest.logarithmic_integral_values_test();
LogisticTest.logistic_cdf_values_test();
MertensTest.mertens_values_test();
MittagLefflerTest.mittag_leffler_ea_values_test();
MoebiusTest.moebius_values_test();
MultinomialTest.multinomial_pdf_values_test();
BinomialTest.negative_binomial_cdf_values_test();
WignerTest.nine_j_values_test();
NormalTest.normal_01_cdf_values_test();
NormalTest.normal_01_pdf_values_test();
NormalTest.normal_cdf_values_test();
NormalTest.normal_pdf_values_test();
OmegaTest.omega_values_test();
OwenTest.owen_values_test();
PartitionTest.partition_count_values_test();
PartitionTest.partition_distinct_count_values_test();
PhiTest.phi_values_test();
PiTest.pi_values_test();
PoissionTest.poisson_cdf_values_test();
LogarithmTest.polylogarithm_values_test();
PolyominoTest.polyomino_chiral_count_values_test();
PolyominoTest.polyomino_fixed_count_values_test();
PolyominoTest.polyomino_free_count_values_test();
PrandtlTest.prandtl_values_test();
PrimeTest.prime_values_test();
PsatTest.psat_values_test();
PsiTest.psi_values_test();
FactorialTest.r8_factorial_values_test();
FactorialTest.r8_factorial_log_values_test();
FactorialTest.r8_factorial2_values_test();
FactorialTest.r8_fall_values_test();
FactorialTest.r8_rise_values_test();
RayleighTest.rayleigh_cdf_values_test();
ChiTest.scaled_inverse_chi_square_pdf_values_test();
SecVirTest.secvir_values_test();
ShiTest.shi_values_test();
SineTest.si_values_test();
SigmaTest.sigma_values_test();
SineTest.sin_values_test();
SineTest.sin_degree_values_test();
SineTest.sin_power_int_values_test();
SineTest.sinh_values_test();
WignerTest.six_j_values_test();
SoundTest.sound_values_test();
SphereTest.sphere_unit_area_values_test();
SphereTest.sphere_unit_volume_values_test();
SphericalHarmonicTest.spherical_harmonic_values_test();
SqrtTest.sqrt_values_test();
StirlingTest.stirling1_values_test();
StirlingTest.stirling2_values_test();
StromgenTest.stromgen_values_test();
StruveTest.struve_h0_values_test();
StruveTest.struve_h1_values_test();
StruveTest.struve_l0_values_test();
StruveTest.struve_l1_values_test();
StudentTest.student_cdf_values_test();
StudentTest.student_noncentral_cdf_values_test();
FactorialTest.subfactorial_values_test();
SurfTensionTest.surten_values_test();
SynchTest.synch1_values_test();
SynchTest.synch2_values_test();
TangentTest.tan_values_test();
TangentTest.tanh_values_test();
TauTest.tau_values_test();
ThermCondTest.thercon_values_test();
WignerTest.three_j_values_test();
TransportationTest.tran02_values_test();
TransportationTest.tran03_values_test();
TransportationTest.tran04_values_test();
TransportationTest.tran05_values_test();
TransportationTest.tran06_values_test();
TransportationTest.tran07_values_test();
TransportationTest.tran08_values_test();
TransportationTest.tran09_values_test();
TrigammaTest.trigamma_values_test();
TruncatedTest.truncated_normal_ab_cdf_test();
TruncatedTest.truncated_normal_ab_pdf_test();
TruncatedTest.truncated_normal_a_cdf_test();
TruncatedTest.truncated_normal_a_pdf_test();
TruncatedTest.truncated_normal_b_cdf_test();
TruncatedTest.truncated_normal_b_pdf_test();
TsatTest.tsat_values_test();
VanDerCorputTest.van_der_corput_values_test();
ViscosityTest.viscosity_values_test();
VonMisesTest.von_mises_cdf_values_test();
DateTest.weekday_values_test();
WeibullTest.weibull_cdf_values_test();
WrightOmegaTest.wright_omega_values_test();
ZetaTest.zeta_values_test();
ZetaTest.zeta_m1_values_test();
Console.WriteLine("");
Console.WriteLine("test_values_test():");
Console.WriteLine(" Normal end of execution.");
Console.WriteLine("");
}
public void Nothing_To_Remove_In_BeTree_If_Try_To_Remove()
{
StudentTest st1 = new StudentTest { FirstName = "Артем", LastName = "Зозуля", TestTitle = ".NET", TestDate = new DateTime(2016, 9, 25), TestResult = 82 };
BiTree<StudentTest> tree = new BiTree<StudentTest>();
tree.Remove(st1);
}
public JsonResult SendTest(int lectureId, HttpPostedFileBase testFile)
{
if (!CookiesManage.Logined())
{
return(Json(new { status = false, mess = "Chưa đăng nhập" }));
}
var user = CookiesManage.GetUser();
using (var workScope = new UnitOfWork(new ELearningDBContext()))
{
var lecture = workScope.Lectures.FirstOrDefault(x => x.Id == lectureId);
if (lecture == null || !lecture.IsTest)
{
return(Json(new { status = false, mess = "Lỗi: Không gửi được bài học này!" }));
}
var studentTest = new StudentTest
{
Username = user.Username
};
try
{
if (testFile?.FileName != null)
{
if (testFile.ContentLength >= FileKey.MaxTestLength)
{
return(Json(new { status = false, mess = L.T("FileMaxLength") }));
}
var splitFilename = testFile.FileName.Split('.');
if (splitFilename.Length > 1)
{
var fileExt = splitFilename[splitFilename.Length - 1];
// //Check ext
if (FileKey.FileTestExtensionApprove().Any(x => x == fileExt))
{
var slugName = StringHelper.ConvertToAlias(user.FullName);
var fileName = slugName + "_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + "." + fileExt;
var path = Path.Combine(Server.MapPath("~/FileUploads/files/test/"), fileName);
testFile.SaveAs(path);
studentTest.FileAnswer = "/FileUploads/files/test/" + fileName;
}
else
{
return(Json(new { status = false, mess = "Lỗi: không hỗ trợ định dạng này!" }));
}
}
else
{
return(Json(new { status = false, mess = "Lỗi: không có nội dung" }));
}
}
studentTest.LectureId = lecture.Id;
studentTest.Status = false;
studentTest.Email = user.Email;
workScope.StudentTests.Add(studentTest);
workScope.Complete();
return(Json(new { status = true, mess = "Gửi tài thành công" }));
}
catch (Exception ex)
{
return(Json(new { status = false, mess = "Lỗi hệ thống!" }));
}
}
}
