private void MergeValidation(FieldValidator validator)
{
if (null != this.validator)
{
this.validator.ErrorCode = validator.ErrorCode;
this.validator.MaxLength = validator.MaxLength;
this.validator.MinLength = validator.MinLength;
if (null != validator.Regex)
{
this.validator.Regex = validator.Regex;
}
if (null != validator.Options && validator.Options.Count > 0)
{
this.validator.Options = validator.Options;
}
this.validator.Required = validator.Required;
this.validator.Disabled = validator.Disabled;
if (null != validator.Message)
{
this.validator.Message = validator.Message;
}
}
else
{
this.validator = validator;
}
}
private void button3_Click(object sender, EventArgs e)
{
FindControls(this, controls, ControlIdentifier);
if (!FieldValidator.HasEmptyFields(controls.ToArray()))
{
if (PasswordBox.Text.Equals(ConfirmPasswordBox.Text))
{
RegisterDoctorModel doctorModel = CreateModel();
doctorService.Save(doctorModel);
MessageBox.Show("Successfully created medical staff profile");
this.Hide();
AdminHomeForm adminHome = new AdminHomeForm();
adminHome.ShowDialog();
this.Close();
}
else
{
MessageBox.Show("Password and Confirm Pasword mismatch");
}
}
else
{
MessageBox.Show("Fill in all fileds");
}
}
public void Initialize()
{
_checker = new DefaultFieldChecker();
_checkerDict = new Dictionary<FieldType, IFieldChecker>();
_checkerDict.Add(new FieldType {Type = FieldType.TypEField.Author}, _checker);
_fv = new FieldValidator(_checkerDict);
}
private void UpdateInterview()
{
using (ModelContext db = new ModelContext())
{
int interviewId;
if (!Int32.TryParse(TextBox_Intvw_ID.Text, out interviewId))
{
throw new ArgumentException($"Value '{TextBox_Intvw_ID.Text}' in Interview ID TextBox could not be parsed.");
}
var interviewDb = db.Interviews.FirstOrDefault(c => c.Id == interviewId);
if (interviewDb == null)
{
throw new ArgumentException($"No Interview found with ID #{interviewId}.");
}
Dictionary <string, string> newInterviewFields = LoadInterviewFieldValues();
FieldValidator.CheckInterviewFields(newInterviewFields);
interviewDb.Type = newInterviewFields["Type"];
interviewDb.Method = newInterviewFields["Method"];
interviewDb.Interviewer = newInterviewFields["Interviewer"];
interviewDb.DateScheduled = DateTime.Parse(newInterviewFields["Date"]);
interviewDb.SkillsRequired = newInterviewFields["Skills"];
interviewDb.Status = newInterviewFields["Status"];
interviewDb.Feedback = newInterviewFields["Feedback"];
interviewDb.Remarks = newInterviewFields["Remarks"];
db.SaveChanges();
LoggingUtility.LogMessage($"Interview #{interviewDb.Id} successfully updated.");
}
}
public void SetCursor(int row, int col)
{
if (FieldValidator.CheckPostion(row, col, BattlefieldSize))
{
Condition[row, col] = -2;
}
}
/// <summary>
/// Calls the validation function for this field, as well as all the validation
/// function for the field's class and its parents.
/// </summary>
public string CallValidator(string text)
{
string classResult = ClassValidator(text);
if (classResult == null)
{
return(null);
}
text = classResult;
FieldValidator userValidator = GetValidator();
if (userValidator != null)
{
string userResult = userValidator(text);
if (userResult == null)
{
// User validator rejects value. Game over.
return(null);
}
text = userResult;
}
return(text);
}
public void ConvertNullSDKToSDK()
{
sdkFieldValidator1 = null;
FieldValidatorConverter converter = new FieldValidatorConverter(sdkFieldValidator1);
Assert.IsNull(converter.ToSDKFieldValidator());
}
public static void requestSetOfFieldsTarget(int[] modX, int[] modY, FieldValidator validator, string hint)
{
GAME.currentRequest = TARGET_TYPE.SET_OF_FIELDS;
GAME.currentValidator = validator;
GAME.setRequestModX = modX;
GAME.setRequestModY = modY;
gmsg(hint);
}
public void IsThereWinningBottomLeftTopRightDiagonalShouldReturnFalse()
{
Field.CreateField(3);
Field.UpdateCellState("3,1");
Field.UpdateCellState("2,2");
Assert.AreEqual(false, FieldValidator.IsThereWinningBottomLeftTopRightDiagonal('O'));
}
private bool HasValue(TextBox textBox, Label label, CancelEventArgs e)
{
ValidationResult result = FieldValidator.HasValue(textBox, label);
_errorProvider.SetError(label, result.Message);
e.Cancel = !result.Succeeded;
return(result.Succeeded);
}
public void IsThereWinningRowShouldBeFalseIfThereIsNoWinningRow()
{
Field.CreateField(3);
Field.UpdateCellState("3,1");
Field.UpdateCellState("3,2");
Assert.AreEqual(false, FieldValidator.IsThereWinningRow('O'));
}
public void IsThereWinningTopLeftBottomRightDiagonalShouldReturnTrue()
{
Field.CreateField(3);
Field.UpdateCellState("1,1");
Field.UpdateCellState("2,2");
Field.UpdateCellState("3,3");
Assert.AreEqual(true, FieldValidator.IsThereWinningTopLeftBottomRightDiagonal('X'));
}
public void IsThereWinningRowShouldBeTrueForThirdRow()
{
Field.CreateField(3);
Field.UpdateCellState("3,1");
Field.UpdateCellState("3,2");
Field.UpdateCellState("3,3");
Assert.AreEqual(true, FieldValidator.IsThereWinningRow('X'));
}
public void IsThereWinningColumnShouldBeTrueForThirdColumn()
{
Field.CreateField(3);
Field.UpdateCellState("1,3");
Field.UpdateCellState("2,3");
Field.UpdateCellState("3,3");
Assert.AreEqual(true, FieldValidator.IsThereWinningColumn('X'));
}
public void ConvertSDKToSDK()
{
sdkFieldValidator1 = CreateTypicalSDKValidator();
FieldValidatorConverter converter = new FieldValidatorConverter(sdkFieldValidator1);
sdkFieldValidator2 = converter.ToSDKFieldValidator();
Assert.IsNotNull(sdkFieldValidator2);
Assert.AreEqual(sdkFieldValidator2, sdkFieldValidator1);
}
public async Task IsValidForRecordingAsync_ForNumberField_ShouldReturnTrue()
{
using (var context = new PreservationContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
var dut = new FieldValidator(context);
var result = await dut.IsValidForRecordingAsync(_numberFieldId, default);
Assert.IsTrue(result);
}
}
public async Task IsVoidedAsync_UnknownId_ShouldReturnFalse()
{
using (var context = new PreservationContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
var dut = new FieldValidator(context);
var result = await dut.IsVoidedAsync(126234, default);
Assert.IsFalse(result);
}
}
public async Task VerifyFieldTypeAsync_ForInfoField_ShouldReturnTrueForInfo()
{
using (var context = new PreservationContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
var dut = new FieldValidator(context);
var result = await dut.VerifyFieldTypeAsync(_infoFieldId, FieldType.Info, default);
Assert.IsTrue(result);
}
}
public async Task IsValidForAttachmentAsync_ForInfoField_ShouldReturnFalse()
{
using (var context = new PreservationContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
var dut = new FieldValidator(context);
var result = await dut.IsValidForAttachmentAsync(_infoFieldId, default);
Assert.IsFalse(result);
}
}
public void Deve_Validar_String_Invalido()
{
var validation = new FieldValidator <FieldValidatorBuilder>();
var builder = FieldValidatorBuilder.FieldInvalid();
validation.NotNullOrEmpty(builder.FieldString, "Valor string invalido");
var validator = validation.Validate(builder);
Assert.False(validator.IsValid);
}
public void Deve_Validar_Int_Invalido()
{
var validation = new FieldValidator <FieldValidatorBuilder>();
var builder = FieldValidatorBuilder.FieldInvalid();
validation.NotNull(builder.FieldInt, "Valor inteiro invalido");
var validator = validation.Validate(builder);
Assert.False(validator.IsValid);
}
public void Deve_Validar_Decimal_Valido()
{
var validation = new FieldValidator <FieldValidatorBuilder>();
var builder = FieldValidatorBuilder.FieldValid();
validation.NotNull(builder.FieldDecimal, "Valor decimal invalido");
var validator = validation.Validate(builder);
Assert.True(validator.IsValid);
}
public void FireAt(int row, int col)
{
if (FieldValidator.CheckPostion(row, col, BattlefieldSize))
{
if (Condition[row, col] == 1)
{
Condition[row, col] = -1;
}
}
}
public void Deve_Validar_Object_Valido()
{
var validation = new FieldValidator <FieldValidatorBuilder>();
var builder = FieldValidatorBuilder.FieldValid();
validation.NotNull(builder.FieldObject, "Valor Object invalido");
var validator = validation.Validate(builder);
Assert.True(validator.IsValid);
}
public void Field_IsValid_ReturnsErrorWithDecimalsOnStringDataType()
{
var model = new Field("Test")
{
Scale = 3
};
var sut = new FieldValidator();
sut.ShouldHaveValidationErrorFor(m => m.Scale, model);
}
public void ConvertAPIToSDK()
{
apiFieldValidation1 = CreateTypicalAPIFieldValidation();
sdkFieldValidator1 = new FieldValidatorConverter(apiFieldValidation1).ToSDKFieldValidator();
Assert.AreEqual(sdkFieldValidator1.Message, apiFieldValidation1.ErrorMessage);
Assert.AreEqual(sdkFieldValidator1.MaxLength, apiFieldValidation1.MaxLength);
Assert.AreEqual(sdkFieldValidator1.MinLength, apiFieldValidation1.MinLength);
Assert.AreEqual(sdkFieldValidator1.Required, apiFieldValidation1.Required);
Assert.IsEmpty(sdkFieldValidator1.Options);
}
public void Field_IsValid_ReturnsErrorWhenMinLengthGreaterThenMaxLength()
{
var model = new Field("Test")
{
MinLength = 45, MaxLength = 5
};
var sut = new FieldValidator();
sut.ShouldHaveValidationErrorFor(m => m.MinLength, model);
}
public void Field_IsValid_ReturnsErrorWithNegativeMinLength()
{
var model = new Field("Test")
{
MinLength = -3
};
var sut = new FieldValidator();
sut.ShouldHaveValidationErrorFor(m => m.MinLength, model);
}
public void Field_IsValid_ReturnsErrorWithNegativeDecimals()
{
var model = new Field("Test")
{
Scale = -3, DataType = DataTypes.Decimal
};
var sut = new FieldValidator();
sut.ShouldHaveValidationErrorFor(m => m.Scale, model);
}
public FieldValidator Build()
{
FieldValidator validator = new FieldValidator();
validator.Regex = regex;
validator.MaxLength = maxLength;
validator.MinLength = minLength;
validator.Required = required;
validator.Message = message;
return(validator);
}
private void ValidateAndSetField <T>(ref T fieldToSet, T value, FieldValidator <T> fieldValidator)
{
if (fieldValidator.Invoke(value, out string errorMessage))
{
fieldToSet = value;
}
else
{
throw new ArgumentException(errorMessage);
}
}
public FieldValidator Build ()
{
Support.LogMethodEntry();
FieldValidator validator = new FieldValidator ();
validator.Regex = regex;
validator.MaxLength = maxLength;
validator.MinLength = minLength;
validator.Required = required;
validator.Message = message;
Support.LogMethodExit(validator);
return validator;
}
public void StartGame(Guid playerId, bool[][] field)
{
if (!_players.Any(p => p.PlayerId == playerId))
ThrowHelper("Player with this name is not connected.");
var fv = new FieldValidator();
if (!fv.Validate(field))
ThrowHelper("Your client has sent invalid field.");
T("Player {0} started the game", playerId);
_players.First(p => p.PlayerId == playerId).Ships = fv.Ships;
if (_players.Count(p => p.IsReady) == 2)
{
_inGame = true;
_players[0].HisTurn = true;
SendStatusToPlayer(_players[0], PlayerMessage.YourTurn);
_players[1].HisTurn = false;
SendStatusToPlayer(_players[1], PlayerMessage.EnemyTurn);
}
}
public FieldBuilder WithValidation (FieldValidator validator)
{
this.validator = validator;
return this;
}
public FieldValidator Build ()
{
FieldValidator validator = new FieldValidator ();
validator.Regex = regex;
validator.MaxLength = maxLength;
validator.MinLength = minLength;
validator.Required = required;
validator.Message = message;
validator.AddOptions(options);
validator.ErrorCode = errorCode;
return validator;
}
