public void IsValidStudentFail()
{
Student aStudent = new Student();
StudentValidator validator = new StudentValidator();
Assert.IsFalse(validator.IsValid(aStudent));
}
public void TestValidator()
{
var student = new Student()
{
Name = "TJ",
GPA = 4.1
};
var validator = new StudentValidator();
Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(string.Empty); // invariant
var validationResult = validator.Validate(student);
Assert.Equal(2, validationResult.Errors.Count);
Assert.Equal("Name must be at least 3 characters long", validationResult.Errors[0].ErrorMessage);
Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("de-DE");
validationResult = validator.Validate(student);
Assert.Equal(2, validationResult.Errors.Count);
Assert.Equal("Das name must be at least 3 characters long", validationResult.Errors[0].ErrorMessage);
}
public void IsValidStudentSuccess()
{
Student aStudent = new Student();
int intTest = 47801236;
string testStrings = "thisIsATest";
aStudent.Id = intTest;
aStudent.Name = testStrings;
aStudent.LastName = testStrings;
Coordinate aCoordinate = new Coordinate();
aCoordinate.X = intTest;
aCoordinate.Y = intTest;
aStudent.Coordinates = aCoordinate;
aStudent.Ci = intTest;
aStudent.StudentNumber = intTest;
List <Subject> subjectList = new List <Subject>();
Subject newSubject = new Subject();
subjectList.Add(newSubject);
aStudent.Subjects = subjectList;
StudentValidator validator = new StudentValidator();
Assert.IsTrue(validator.IsValid(aStudent));
}
public void IsValidDifferentObjectFail()
{
StudentValidator validator = new StudentValidator();
int testInt = 5;
Assert.IsFalse(validator.IsValid(testInt));
}
public async Task CreateStudent(CreateStudentInput createStudentsInput)
{
try
{
var validationMaessage = string.Empty;
var studentValidator = new StudentValidator();
var result = studentValidator.Validate(createStudentsInput);
if (result.IsValid)
{
using (var unitOfWork = _unitOfWorkManager.Begin())
{
var student = base.ObjectMapper.Map <Student>(createStudentsInput);
await _studentRepository.InsertAsync(student);
unitOfWork.Complete();
}
}
else
{
foreach (var failure in result.Errors)
{
validationMaessage += "Property " + failure.PropertyName + " failed validation. Error was: " + failure.ErrorMessage + Environment.NewLine;
}
throw new UserFriendlyException(validationMaessage);
}
}
catch (Exception ex)
{
throw new UserFriendlyException(ex.Message);;
}
}
static void Main(string[] args)
{
IValidator <Student> StudentValidator = new StudentValidator();
IValidator <Tema> TemaValidator = new TemaValidator();
IValidator <Nota> NotaValidator = new NotaValidator();
StudentFileRepository StudentRepo = new StudentFileRepository(StudentValidator, "D:/Documente/ANUL 2/Semestrul 1/Metode Avansate De Programare/LABORATOARE/LAB9/LAB9-2/LAB9-2/studenti.txt");
TemaFileRepository TemaRepo = new TemaFileRepository(TemaValidator, "D:/Documente/ANUL 2/Semestrul 1/Metode Avansate De Programare/LABORATOARE/LAB9/LAB9-2/LAB9-2/teme.txt");
NotaFileRepository NotaRepo = new NotaFileRepository(NotaValidator, StudentRepo, TemaRepo, "D:/Documente/ANUL 2/Semestrul 1/Metode Avansate De Programare/LABORATOARE/LAB9/LAB9-2/LAB9-2/note.txt");
Service Serv = new Service(StudentRepo, TemaRepo, NotaRepo);
UI Consola = new UI(Serv);
Consola.Run();
////------------------------
//List<Student> cars = new List<Student>();
//cars.Add(new Student("1", "ana", 221));
//cars.Add(new Student("2", "ana1", 222));
//cars.Add(new Student("3", "ana2", 221));
//cars.Add(new Student("4", "ana3", 223));
//cars.Add(new Student("5", "ana4", 221));
//cars.Add(new Student("6", "ana5", 222));
//IEnumerable<IGrouping<int, Student>> carGroups = cars.GroupBy(c => c.Grupa);
////-----------------
//foreach (IGrouping<int, Student> g in carGroups)
//{
// Console.WriteLine(g.Key);
// foreach (Student c in g)
// Console.WriteLine(c);
//}
//Console.ReadKey();
}
private IEnumerable <StudentDTO> GetValidStudentsWrongWay()
{
return(_context.Students.Where(
x => x.Name.Length > 2 &&
StudentValidator.IsValid(x))
.Select(x => x.ToDtoStudent()));
}
public AddStudentResponse AddStudent(Student student)
{
var validator = new StudentValidator();
var results = validator.Validate(student);
if (results.IsValid == false)
{
var messages = new List <string>();
foreach (var item in results.Errors)
{
messages.Add(item.ErrorMessage);
}
return(new AddStudentResponse()
{
ErrorMessage = messages,
Status = false
});
}
using (var unitOfWork =
new UnitOfWork(new DatabaseContext()))
{
unitOfWork.Students.Add(student);
unitOfWork.Complete();
}
return(new AddStudentResponse {
Status = true
});
}
private static void ValidateStudent(Student student)
{
var validator = new StudentValidator();
var results = validator.Validate(student);
if (results.IsValid)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Student are successfully validated.");
Console.ForegroundColor = ConsoleColor.Gray;
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Failed. Errors:");
Console.ForegroundColor = ConsoleColor.DarkRed;
foreach (ValidationFailure failure in results.Errors)
{
Console.WriteLine(failure.ErrorMessage);
}
Console.ForegroundColor = ConsoleColor.Gray;
}
Console.WriteLine();
}
private bool CanIAdd(Object anObject)
{
StudentValidator validator = new StudentValidator();
bool domainValidations = validator.IsValid(anObject);
bool validation = domainValidations && IsNewUser(anObject);
return(validation);
}
public StudentService(
IStorageBroker storageBroker,
ILoggingBroker loggingBroker)
{
this.storageBroker = storageBroker;
this.loggingBroker = loggingBroker;
this.studentValidator = new StudentValidator();
}
public StudentServiceTests()
{
this.storageBrokerMock = new Mock <IStorageBroker>();
this.loggingBrokerMock = new Mock <ILoggingBroker>();
this.studentValidator = new StudentValidator();
this.studentService = new StudentService(
storageBroker: this.storageBrokerMock.Object,
loggingBroker: this.loggingBrokerMock.Object);
}
public override void Validate()
{
var validator = new StudentValidator();
var validationResult = validator.Validate(this);
if (!validationResult.IsValid)
{
throw new ValidationException(validationResult.Errors.Select(i => i.ErrorCode));
}
}
public ActionResult <Student> RegisterStudent([FromBody] Student student)
{
if (StudentValidator.IsUsernameExists(student))
{
return(BadRequest(ErrorHandler.GenerateError(999, "Username already exists.")));
}
_studentRepo.Create(student);
return(student);
}
private bool ModifyValidation(Object anObject, Object anotherObject)
{
StudentValidator validator = new StudentValidator();
bool domainValidation = validator.IsValid(anotherObject);
bool nonExists = !Exists(anotherObject);
bool sameId = anObject.Equals(anotherObject);
Student aStudent = anObject as Student;
Student anotherStudent = anotherObject as Student;
bool sameCI = aStudent.Ci.Equals(anotherStudent.Ci);
return(domainValidation && (nonExists || IsTheSameIdWithNewNonExistenCi(anObject, anotherObject)));
}
public string this[string columnName]
{
get
{
if (validator == null)
{
validator = new StudentValidator();
}
var firstOrDefault = validator.Validate(this)
.Errors.FirstOrDefault(lol => lol.PropertyName == columnName);
return(firstOrDefault?.ErrorMessage);
}
}
public void Validate_WhenAgeIsUnder18_ReturnsFalse()
{
//Arrange
var validator = new StudentValidator(null);
var student = new Student();
student.Age = 17;
//Act
var result = validator.Validate(student);
//Assert
Assert.IsFalse(result);
}
public ActionResult Post(StudentDTO studentDTO)
{
Student student = studentDTO.Adapt <Student>();
var validator = new StudentValidator();
var results = validator.Validate(student);
if (!results.IsValid)
{
StatusCode(400);
return(StatusCode(400));
}
return(Ok());
}
public ActionResult Index(Student student)
{
var validator = new StudentValidator();
var result = validator.Validate(student);
if (!result.IsValid)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
}
}
return(View(student));
}
public void IsApprovedForCSN_WhenStudentIsNotRegistered_ReturnsFalse()
{
//Arrange
var stubRepo = new FakeRepository();
var student = new Student();
student.Age = 21;
var validator = new StudentValidator(stubRepo, student);
//Act
var result = validator.IsApprovedForCSN();
//Assert
Assert.IsFalse(result);
}
public IActionResult EditPersonalInfo(long id, StudentDto request)
{
Student student = _studentRepository.GetById(id);
var validator = new StudentValidator();
validator.Validate(request);
var addresses = request.Addresses.Select(a => new Address(a.Street, a.City, a.State, a.ZipCode)).ToList();
//student.EditPersonalInfo(new StudentName(request.Name), addresses);
_studentRepository.Save(student);
return(Ok());
}
public async Task <SignUpToCourseCommandResponse> Handle(SignUpToCourseCommand command)
{
var student = new Student(command.Name, command.Email, command.DateOfBirth);
var studentValidator = new StudentValidator();
var validationResult = studentValidator.Validate(student);
var response = new SignUpToCourseCommandResponse();
if (validationResult.IsValid)
{
var course = await _repository.GetByIdAsync(command.CourseId);
if (course == null)
{
response.Message = "Course not found.";
response.AddError($"Course Id '{command.CourseId}' not found.");
}
else if (course.IsFull)
{
response.Message = "Course max students number reached.";
response.AddError("Sorry, We this course is closed for new students.");
}
else
{
course.NumberOfStudents += 1;
var success = await _repository.AddStudentToCourseAsync(course, student);
if (success)
{
response.Message = "OK";
response.Course = course;
response.Student = student;
}
if (!success)
{
response.Message = "Oops, Something went wrong.";
response.AddError("Sorry, We had a problem enrolling you to this course, try later.");
}
}
}
else
{
response.Message = "Oops, Something went wrong.";
response.AddErrorsRange(validationResult.Errors.Select(v => v.ErrorMessage));
}
return(response);
}
public void Validate_WhenStudentIsValid_ReturnsTrue()
{
//Arrange
var fakeRepo = new FakeStudentRepository();
fakeRepo.HasRegistered = true;
var validator = new StudentValidator(fakeRepo);
var student = new Student();
student.Age = 20;
//Act
var result = validator.Validate(student);
//Assert
Assert.IsTrue(result);
}
public async Task <IHttpActionResult> PostStudentEntity(Guid classId, StudentEntity studentEntity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
StudentValidator validator = new StudentValidator(classId);
ValidationResult results = validator.Validate(studentEntity);
bool validationSucceeded = results.IsValid;
if (!validationSucceeded)
{
return(BadRequest("Surname must be unique."));
}
db.StudentEntities.Add(studentEntity);
try
{
await db.SaveChangesAsync();
var classEntity = db.ClassEntities.Find(classId);
classEntity.StudentEntities.Add(studentEntity);
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (StudentEntityExists(studentEntity.ID))
{
return(Conflict());
}
else
{
throw;
}
}
return(Ok(studentEntity.ID)); //CreatedAtRoute("DefaultApi", new { id = studentEntity.ID }, studentEntity);
}
public override void PromptInput()
{
base.PromptInput();
Console.WriteLine("Unesite nivo studija:");
Console.WriteLine("1. Bachelor");
Console.WriteLine("2. Master");
int index = Parser.GetNextNumber(true, 1, 2);
Level = (Levels)index;
Console.Write("Unesite index: ");
Index = Console.ReadLine();
while (!StudentValidator.IsIndexValid(Index))
{
Console.WriteLine("Index nije validan, unesite ponovo: ");
Index = Console.ReadLine();
}
}
public StudentValidatorTests()
{
_studentValidator = new StudentValidator();
}
public Course(StudentValidator validator_)
{
;
validator = validator_;
participants = new List <Student>();
}
public StudentTest()
{
validator = new StudentValidator();
}
public StudentService(IUnitOfWork uow, IMapper mapper, StudentValidator studentValidator)
{
_uow = uow;
_mapper = mapper;
_studentValidator = studentValidator;
}
private void btnAdd_Click(object sender, EventArgs e)
{
student studentModel = new student();
try
{
studentModel.Id = txtNationalId.Text.Trim();
studentModel.name = txtName.Text.Trim();
studentModel.gender = cbGender.selectedValue.Trim();
studentModel.nat = txtNational.Text.Trim();
//studentModel.dob = DateTime.ParseExact(txtDOB.Text.Trim(), "d/M/yyyy", CultureInfo.InvariantCulture).Date;
if (validDOB(txtDOB.Text.Trim()) != null)
{
studentModel.dob = validDOB(txtDOB.Text.Trim()).Value.Date;
}
studentModel.date = DateTime.Now.Date;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Validate
StudentValidator validator = new StudentValidator();
var result = validator.Validate(studentModel);
if (result.IsValid == false)
{
//foreach (ValidationFailure failure in result.Errors)
//{
// //com.Alert($"{failure.ErrorMessage}", Alert.enmType.Error);
// MessageBox.Show($"{failure.ErrorMessage}");
//}
MessageBox.Show($"{result.Errors[0].ErrorMessage}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.DialogResult = DialogResult.None;
return;
}
//Insert
using (hcDataContext db = new hcDataContext())
{
try
{
db.students.InsertOnSubmit(studentModel);
db.SubmitChanges();
}
catch (DbEntityValidationException ex)
{
foreach (var errors in ex.EntityValidationErrors)
{
foreach (var validationError in errors.ValidationErrors)
{
// get the error message
string errorMessage = validationError.ErrorMessage;
MessageBox.Show(errorMessage);
}
}
}
}
}
