public static IsTrueAssertOperation <TValue> IsTrue <TValue>(IAssert assert, IResultOperation <TValue, bool> operation)
{
if (assert == null)
{
throw new ArgumentNullException(nameof(assert));
}
if (operation == null)
{
throw new ArgumentNullException(nameof(operation));
}
return(new IsTrueAssertOperation <TValue>(assert, operation));
}
protected void btnAddNewWorker_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(this.txtNewWorkerName.Text))
{
this.lblNewWorkerMessage.Text = "O nome deve ser preenchido!";
return;
}
if (string.IsNullOrWhiteSpace(this.txtNewWorkerLastName.Text))
{
this.lblNewWorkerMessage.Text = "o Sobrenome deve ser preenchido!";
return;
}
WorkerBusinessLogic workerBusinessLogic = new WorkerBusinessLogic();
Worker Worker = new Worker();
Worker.Name = txtNewWorkerName.Text;
Worker.LastName = txtNewWorkerLastName.Text;
IResultOperation result = workerBusinessLogic.InsertWithRule(Worker);
if (result.Status != ResultOperationStatus.OK)
{
lblNewWorkerMessage.Text = result.Message;
return;
}
BindGridViewWorkers();
ScriptManager.RegisterClientScriptBlock(this,
this.GetType(),
"AddHideModalScript",
Util.GetScriptToHideModalDialog("addModal"),
false);
this.txtNewWorkerName.Text = string.Empty;
this.txtNewWorkerLastName.Text = string.Empty;
this.lblNewWorkerMessage.Text = string.Empty;
}
protected void btnAddNewProject_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(this.txtNewPrjectName.Text))
{
lblNewPrjectMessage.Text = "O nome deve ser preenchido!";
return;
}
if (string.IsNullOrWhiteSpace(this.txtNewPrjectDescription.Text))
{
lblNewPrjectMessage.Text = "A descrição deve ser preenchido!";
return;
}
ProjectBusinessLogic projectBusinessLogic = new ProjectBusinessLogic();
Project project = new Project()
{
Name = txtNewPrjectName.Text,
Description = txtNewPrjectDescription.Text
};
IResultOperation result = projectBusinessLogic.InsertWithRule(project);
if (result.Status != ResultOperationStatus.OK)
{
lblNewPrjectMessage.Text = result.Message;
return;
}
BindGridViewProjects();
ScriptManager.RegisterClientScriptBlock(this,
this.GetType(),
"AddHideModalScript",
Util.GetScriptToHideModalDialog("addModal"),
false);
this.txtNewPrjectName.Text = string.Empty;
this.txtNewPrjectDescription.Text = string.Empty;
}
protected void btnUpdateWorker_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(this.txtEditWorkerName.Text))
{
lblEditWorkerMessage.Text = "O nome deve ser preenchido!";
return;
}
if (string.IsNullOrWhiteSpace(this.txtEditWorkerLastName.Text))
{
lblEditWorkerMessage.Text = "o Sobrenome deve ser preenchido!";
return;
}
WorkerBusinessLogic workerBusinessLogic = new WorkerBusinessLogic();
Worker worker = workerBusinessLogic.GetByID(Convert.ToInt32(HfUpdateID.Value));
string currentName = worker.Name;
worker.Name = txtEditWorkerName.Text;
worker.LastName = txtEditWorkerLastName.Text;
IResultOperation result = workerBusinessLogic.UpdatetWithRule(worker);
if (result.Status != ResultOperationStatus.OK)
{
lblEditWorkerMessage.Text = result.Message;
worker.Name = currentName;
return;
}
BindGridViewWorkers();
ScriptManager.RegisterClientScriptBlock(this,
this.GetType(),
"EditHideModalScript",
Util.GetScriptToHideModalDialog("editModal"),
false);
lblEditWorkerMessage.Text = string.Empty;
}
public override void Update(T obj)
{
IResultOperation result = UpdatetWithRule(obj);
if (result.Status == ResultOperationStatus.OK)
{
return;
}
string message = string.Format("A entidade {0} não passou nas regras do método UpdatetWithRule "
+ Environment.NewLine
+ "{1}",
this.GetType().ToString(),
result.Message);
throw new Exception(message, result.Exception);
}
protected void btnUpdateProject_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(this.txtEditProjectName.Text))
{
lblEditPrjectMessage.Text = "O nome deve ser preenchido!";
return;
}
if (string.IsNullOrWhiteSpace(this.txtEditProjectDescription.Text))
{
lblEditPrjectMessage.Text = "A descrição deve ser preenchido!";
return;
}
ProjectBusinessLogic projectBusinessLogic = new ProjectBusinessLogic();
Project project = projectBusinessLogic.GetByID(Convert.ToInt32(HfUpdateID.Value));
string currentName = project.Name;
project.Name = txtEditProjectName.Text;
project.Description = txtEditProjectDescription.Text;
IResultOperation result = projectBusinessLogic.UpdatetWithRule(project);
if (result.Status != ResultOperationStatus.OK)
{
this.lblEditPrjectMessage.Text = result.Message;
project.Name = currentName;
return;
}
BindGridViewProjects();
ScriptManager.RegisterClientScriptBlock(this,
this.GetType(),
"EditHideModalScript",
Util.GetScriptToHideModalDialog("editModal"),
false);
lblEditPrjectMessage.Text = string.Empty;
}
public override IResultOperation InsertWithRule(Project obj)
{
IResultOperation result = null;
string message = string.Empty;
obj.Name = obj.Name.Trim();
IList <Project> list = this.GetAll().Where(p => p.Name.Equals(obj.Name)).ToList();
if (list.Count() >= 1)
{
message = "Esse nome de projeto já existe!";
result = new OperationResultBusinessLogic(message, ResultOperationStatus.Problem);
return(result);
}
this.baseDataAccessLayer.Insert(obj);
result = new OperationResultBusinessLogic("Projeto inserido com sucesso", ResultOperationStatus.OK);
return(result);
}
public override IResultOperation UpdatetWithRule(Worker obj)
{
IResultOperation result = null;
string message = string.Empty;
obj.Name = obj.Name.Trim();
IList <Worker> list = this.GetAll().Where(p => p.Name.Equals(obj.Name) && p.ID != obj.ID).ToList();
if (list.Count() >= 1)
{
message = "Esse nome já existe!";
result = new OperationResultBusinessLogic(message, ResultOperationStatus.Problem);
return(result);
}
this.baseDataAccessLayer.Insert(obj);
result = new OperationResultBusinessLogic("Colaborador cadastrado com sucesso", ResultOperationStatus.OK);
return(result);
}
internal AreNotSameAssertOperation(IAssert assert, IResultOperation <TValue, TResult> operation, TResult expected)
: base(assert, operation, expected)
{
}
public static AreNotSequenceEqualAssertOperation <TValue, TResult> AreNotSequenceEqual <TValue, TResult>(IAssert assert, IResultOperation <TValue, IEnumerable <TResult> > operation, IEnumerable <TResult> expected)
{
if (assert == null)
{
throw new ArgumentNullException(nameof(assert));
}
if (operation == null)
{
throw new ArgumentNullException(nameof(operation));
}
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
return(new AreNotSequenceEqualAssertOperation <TValue, TResult>(assert, operation, expected));
}
public AreNotEqualAssertOperation <TValue, TResult> AreNotEqual <TValue, TResult>(IResultOperation <TValue, TResult> operation, TResult expected) => AssertOperation.AreNotEqual(_assert, operation, expected);
public AreNotSameAssertOperation <TValue, TResult> AreNotSame <TValue, TResult>(IResultOperation <TValue, TResult> operation, TResult expected) where TResult : class => AssertOperation.AreNotSame(_assert, operation, expected);
public static AreSameAssertOperation <TValue, TResult> AreSame <TValue, TResult>(IAssert assert, IResultOperation <TValue, TResult> operation, TResult expected) where TResult : class
{
if (assert == null)
{
throw new ArgumentNullException(nameof(assert));
}
if (operation == null)
{
throw new ArgumentNullException(nameof(operation));
}
return(new AreSameAssertOperation <TValue, TResult>(assert, operation, expected));
}
internal IsTrueAssertOperation(IAssert assert, IResultOperation <TValue, bool> operation)
: base(assert, operation, expected: true)
{
}
public AreNotSequenceEqualAssertOperation <TValue, TResult> AreNotSequenceEqual <TValue, TResult>(IResultOperation <TValue, IEnumerable <TResult> > operation, IEnumerable <TResult> expected) => AssertOperation.AreNotSequenceEqual(_assert, operation, expected);
public static SelectResultOperation <TValue, TResult, TNewResult> Select <TValue, TResult, TNewResult>(this IResultOperation <TValue, TResult> operation, Expression <Func <TResult, TNewResult> > selector) => ResultOperation.Select(operation, selector);
protected AssertExpectedOperation(IAssert assert, IResultOperation <TValue, TResult> operation, TResult expected)
: base(assert, operation)
{
Expected = expected;
}
public IsTrueAssertOperation <TValue> IsTrue <TValue>(IResultOperation <TValue, bool> operation) => AssertOperation.IsTrue(_assert, operation);
public static ApplyOperation <TValue, TResult> Apply <TValue, TResult>(this IResultOperation <TValue, TResult> operation, Expression <Func <TResult, IOperation <TValue> > > selector) => ResultOperation.Apply(operation, selector);
internal AreNotSequenceEqualAssertOperation(IAssert assert, IResultOperation <TValue, IEnumerable <TResult> > operation, IEnumerable <TResult> expected)
: base(assert, operation, expected)
{
}
