public async Task FilterBasedOnOperative()
{
// arrange
var expectedOperative = new Operative
{
PayrollNumber = "prn",
Email = "*****@*****.**"
};
var unExpectedOperative = new Operative
{
PayrollNumber = "anotherprn"
};
_userServiceMock.SetUser("id", expectedOperative.Email, "name");
_userServiceMock.SetSecurityGroup(UserGroups.Operative);
var expectedWorkOrder = CreateWorkOrder(wo => wo.AssignedOperatives = new List <Operative> {
expectedOperative
});
var unExpectedWorkOrders = CreateWorkOrders(5, wo => wo.AssignedOperatives = new List <Operative> {
unExpectedOperative
}).ToList();
unExpectedWorkOrders.AddRange(CreateWorkOrders(5));
await SaveWorkOrderToDb(expectedWorkOrder);
await SaveWorkOrdersToDb(unExpectedWorkOrders);
// act
var workOrders = await _classUnderTest.GetWorkOrders();
// assert
workOrders.Should().ContainSingle(wo => wo.Id == expectedWorkOrder.Id);
workOrders.Should().NotContain(wo => unExpectedWorkOrders.Any(uwo => uwo.Id == wo.Id));
}
public async Task OperativeCanGetWorkOrderById()
{
// arrange
var expectedOperative = new Operative
{
PayrollNumber = "payrollNumber",
Email = "*****@*****.**",
Name = "operativeName"
};
_userServiceMock.SetSecurityGroup(UserGroups.Operative);
_userServiceMock.SetUser("id", expectedOperative.Email, expectedOperative.Name, null, null, null, expectedOperative.PayrollNumber);
var expectedWorkOrder = CreateWorkOrder(wo => wo.AssignedOperatives = new List <Operative> {
expectedOperative
});
await SaveWorkOrderToDb(expectedWorkOrder);
// act
var workOrders = await _classUnderTest.GetWorkOrder(expectedWorkOrder.Id);
// assert
workOrders.Should().BeEquivalentTo(expectedWorkOrder);
}
public async Task OperativeCannotGetWorkOrderByIdWhenNotAssigned()
{
// arrange
var expectedOperative = new Operative
{
PayrollNumber = "payrollNumber",
Email = "*****@*****.**",
Name = "operativeName"
};
_userServiceMock.SetSecurityGroup(UserGroups.Operative);
_userServiceMock.SetUser("id", expectedOperative.Email, expectedOperative.Name, null, null, null, $"not{expectedOperative.PayrollNumber}");
var expectedWorkOrder = CreateWorkOrder(wo => wo.AssignedOperatives = new List <Operative> {
expectedOperative
});
await SaveWorkOrderToDb(expectedWorkOrder);
// act
Func <Task <WorkOrder> > func = async() => await _classUnderTest.GetWorkOrder(expectedWorkOrder.Id);
// assert
await func.Should().ThrowAsync <UnauthorizedAccessException>();
}
public async Task <IActionResult> Edit(int id, [Bind("OperativeID,Name")] Operative operative)
{
if (id != operative.OperativeID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(operative);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OperativeExists(operative.OperativeID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(operative));
}
public async Task <IActionResult> Create([Bind("OperativeID,Name")] Operative operative)
{
if (ModelState.IsValid)
{
_context.Add(operative);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(operative));
}
private Operative SetupOperative(string email = "*****@*****.**")
{
var expectedOperative = new Operative
{
PayrollNumber = "prn",
Email = email
};
_operativesGatewayMock.Setup(x => x.GetAsync(expectedOperative.PayrollNumber))
.ReturnsAsync(expectedOperative);
return(expectedOperative);
}
private async Task <Operative> AddOperativeToDB(Action <Operative> modifier = null)
{
using var ctx = GetContext();
var db = ctx.DB;
var operative = new Operative();
modifier?.Invoke(operative);
await db.Operatives.AddAsync(operative);
await db.SaveChangesAsync();
return(operative);
}
public void Insert(Operative operative)
{
try
{
if (operative.Id == Guid.Empty)
{
operative.Id = Guid.NewGuid();
}
this.Table.Add(operative);
this.SubmitChanges();
}
catch
{
throw;
}
}
public static void LogOperative(Operative operative)
{
var model = new
{
Id = operative?.Id,
PayrollNumber = operative?.PayrollNumber,
IsArchived = operative?.IsArchived,
Name = operative?.Name,
ResourceId = operative?.ResourceId,
Email = operative?.Email,
};
string jsonString = JsonConvert.SerializeObject(model);
Log.Logger.Information("Operative = ", jsonString);
}
public void Delete(Operative entity)
{
try
{
if (entity == null)
{
return;
}
this.Table.Remove(entity);
this.SubmitChanges();
}
catch
{
throw;
}
}
public void Save(Operative operative)
{
try
{
if (operative.Id == Guid.Empty)
{
this.Insert(operative);
}
else
{
this.SubmitChanges();
}
}
catch
{
throw;
}
}
private void btnRegister_Click(object sender, RoutedEventArgs e)
{
try
{
var errorMessage = string.Empty;
var isValidated = ValidateForm(out errorMessage);
if (!isValidated)
{
//رخداد خطا
throw new Exception(errorMessage);
}
var operative = new Operative();
if (operativeId != Guid.Empty)
{
operative = Business.GetOperativeBusiness().GetById(operativeId);
}
else
{
operative = Business.GetOperativeBusiness().GetByOName(txtName.Text);
}
if (operative == null)
{
operative = new Operative();
}
operative.OType = cmbOperativeType.SelectedValue.ToGUID();
operative.OCalculationMethod = cmbCalculationMethod.SelectedValue.ToGUID();
operative.OISEffective = chboxIsEffective.IsChecked;
operative.OPercent = txtPercent.Text.ToNullableDecimal();
operative.OName = txtName.Text;
Business.GetOperativeBusiness().Save(operative);
this.Close();
}
catch (Exception ex)
{
AccountingKernel.Forms.Base.BaseWindow.ShowError(ex);
}
}
private static async Task AddOperativeToTb(Operative operative)
{
InMemoryDb.Instance.Operatives.Add(operative);
await InMemoryDb.Instance.SaveChangesAsync();
}
