public void GetCases()
{
CaseViewModel mockRecord = new CaseViewModel {
CaseId = 1, LastModifiedDate = DateTime.Now, CreatedDate = DateTime.Now, Title = "title 0", Description = "test 0"
};
Case mockEntityModel = new Case {
CaseId = 1, LastModifiedDate = DateTime.Now, CreatedDate = DateTime.Now, Title = "title 0", Description = "test 0"
};
var mockList = new List <Case>();
mockList.Add(new Case {
CaseId = 1, LastModifiedDate = DateTime.Now, CreatedDate = DateTime.Now, Title = "title 0", Description = "test 0"
});
mockMapper.Setup(m => m.Map <CaseViewModel, Case>(It.IsAny <CaseViewModel>())).Returns(mockEntityModel);
mockMapper.Setup(m => m.Map <Case, CaseViewModel>(It.IsAny <Case>())).Returns(mockRecord);
mockMapper.Setup(m => m.Map <IEnumerable <Case>, IEnumerable <CaseViewModel> >(It.IsAny <List <Case> >())).Returns(new List <CaseViewModel> {
mockRecord
});
mockRepository.Setup(m => m.GetCases()).Returns(mockList);
var mockService = new CasesService(mockRepository.Object, mockMapper.Object);
var result = mockService.GetCases();
Assert.AreEqual(1, result.Count());
Assert.AreEqual(result.FirstOrDefault().CaseId, mockRecord.CaseId);
Assert.AreEqual(result.FirstOrDefault().Title, mockRecord.Title);
Assert.AreEqual(result.FirstOrDefault().Description, mockRecord.Description);
mockService.Should().NotBeNull();
}
public async Task DeleteCaseByIdTests()
{
var listOfCases = new List <Case>()
{
new Case()
{
Id = "1",
},
new Case()
{
Id = "2",
},
new Case()
{
Id = "3",
},
};
var mockCasesRepo = new Mock <IDeletableEntityRepository <Case> >();
var mockNotesRepo = new Mock <IDeletableEntityRepository <Note> >();
mockCasesRepo.Setup(r => r.AllAsNoTracking()).Returns(listOfCases.AsQueryable);
mockCasesRepo.Setup(x => x.Delete(It.IsAny <Case>())).Callback(
(Case caseToDelete) => listOfCases
.Where(x => x.Id == caseToDelete.Id)
.FirstOrDefault().IsDeleted = true);
var notesService = new NotesService(mockNotesRepo.Object);
var casesService = new CasesService(mockCasesRepo.Object, notesService);
await casesService.DeleteCaseByIdAsync("1");
Assert.Equal(3, listOfCases.Count());
Assert.True(listOfCases.Where(x => x.Id == "1").FirstOrDefault().IsDeleted);
}
public SubmitModel(ILogger <SubmitModel> logger, CountriesService counServ, CasesService caseServ, UsersService usersServ)
{
_logger = logger;
MyCountriesService = counServ;
MyCasesService = caseServ;
MyUsersService = usersServ;
}
public DashboardModel(ILogger <DashboardModel> logger, CountriesService counServ, CasesService caseServ, UsersService usersServ)
{
_logger = logger;
MyCountriesService = counServ;
MyCasesService = caseServ;
MyUsersService = usersServ;
}
public void AddCase()
{
CaseViewModel mockRecord = new CaseViewModel {
CaseId = 2, LastModifiedDate = DateTime.Now, CreatedDate = DateTime.Now, Title = "title 0", Description = "test 0"
};
Case mockEntityModel = new Case {
CaseId = 2, LastModifiedDate = DateTime.Now, CreatedDate = DateTime.Now, Title = "title 0", Description = "test 0"
};
mockMapper.Setup(m => m.Map <Case, CaseViewModel>(It.IsAny <Case>())).Returns(mockRecord);
mockMapper.Setup(m => m.Map <CaseViewModel, Case>(It.IsAny <CaseViewModel>())).Returns(mockEntityModel);
CaseViewModel request = new CaseViewModel {
CaseId = 2, LastModifiedDate = DateTime.Now, CreatedDate = DateTime.Now, Title = "title 0", Description = "test 0"
};
mockRepository.Setup(m => m.AddCase(It.IsAny <Case>())).Returns(true);
var mockService = new CasesService(mockRepository.Object, mockMapper.Object);
var result = mockService.AddCase(request);
mockService.Should().NotBeNull();
Assert.AreEqual(true, result);
}
public async Task CreateCaseTests()
{
AutoMapperConfig.RegisterMappings(typeof(CreateCaseInputViewModel).GetTypeInfo().Assembly);
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "TestCreateCaseDb")
.Options;
using var dbContext = new ApplicationDbContext(options);
dbContext.Cases.AddRange(
new Case()
{
CaseNumber = "1",
AttorneyId = "1",
ClientId = "1",
JudgeId = 1,
TrusteeId = 1,
DateFiled = DateTime.UtcNow,
});
dbContext.SaveChanges();
using var casesRepository = new EfDeletableEntityRepository <Case>(dbContext);
using var notesRepository = new EfDeletableEntityRepository <Note>(dbContext);
var notesService = new NotesService(notesRepository);
var casesService = new CasesService(casesRepository, notesService);
var workingInput = new CreateCaseInputViewModel()
{
CaseNumber = "2",
AttorneyId = "2",
JudgeId = "2",
TrusteeId = "2",
DateFiled = DateTime.UtcNow,
};
var duplicateCaseNumberInput = new CreateCaseInputViewModel()
{
CaseNumber = "1",
AttorneyId = "2",
JudgeId = "2",
TrusteeId = "2",
DateFiled = DateTime.UtcNow,
};
var caseId = await casesService.CreateCaseAsync("newClient", workingInput);
Assert.True(caseId is string);
await Assert.ThrowsAsync <ArgumentException>(
async() =>
{
await casesService.CreateCaseAsync("newClient", duplicateCaseNumberInput);
});
Assert.Equal(2, casesRepository.AllAsNoTracking().Count());
}
public ActionResult Save(Cases cases)
{
if (cases != null)
{
cases.CaseType = (int)CaseType;
}
cases = CasesService.SaveCase(cases);
return(RedirectToAction("Edit", new RouteValueDictionary(new { id = cases.CaseId })));
}
public void GetAllCasesForClientTests()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "TestGetAllCasesForClientDb")
.Options;
using var dbContext = new ApplicationDbContext(options);
dbContext.Cases.AddRange(
new Case()
{
CaseNumber = "1",
Attorney = new ApplicationUser()
{
FirstName = "niki",
LastName = "mitrev",
},
ClientId = "1",
Judge = new Judge(),
Trustee = new Trustee(),
DateFiled = DateTime.UtcNow,
},
new Case()
{
CaseNumber = "3",
Attorney = new ApplicationUser()
{
FirstName = "niki",
LastName = "mitrev",
},
ClientId = "1",
Judge = new Judge(),
Trustee = new Trustee(),
DateFiled = DateTime.UtcNow.AddDays(1),
});
dbContext.SaveChanges();
using var casesRepository = new EfDeletableEntityRepository <Case>(dbContext);
using var notesRepository = new EfDeletableEntityRepository <Note>(dbContext);
var notesService = new NotesService(notesRepository);
var casesService = new CasesService(casesRepository, notesService);
AllClientCasesViewModel result = casesService.GetAllCasesForClient("1", "Gosho");
var countOfCases = result.Cases.Count();
var clientName = result.ClientName;
var caseOnTop = result.Cases.First();
Assert.Equal(2, countOfCases);
Assert.Equal("Gosho", clientName);
Assert.Equal("3", caseOnTop.CaseNumber);
}
public ActionResult Index()
{
ViewBag.Title = NavigationName;
var pagination = base.GetPage();
ViewBag.Cases = CasesService.LoadSimpleCases(pagination.Pagination, CaseType);
BuildPagination(pagination);
return(View("Index"));
}
private async void LoadData()
{
try
{
var service = new CasesService(_user.Token);
News = new ObservableCollection <News>(await service.GetAll());
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void GetCaseByIdTests()
{
AutoMapperConfig.RegisterMappings(typeof(CreateCaseInputViewModel).GetTypeInfo().Assembly);
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "TestGetCaseByIdDb")
.Options;
using var dbContext = new ApplicationDbContext(options);
dbContext.Cases.AddRange(
new Case()
{
Id = "newId",
CaseNumber = "1",
Attorney = new ApplicationUser()
{
FirstName = "niki",
LastName = "mitrev",
},
ClientId = "1",
Judge = new Judge(),
Trustee = new Trustee(),
DateFiled = DateTime.UtcNow,
},
new Case()
{
CaseNumber = "3",
Attorney = new ApplicationUser()
{
FirstName = "niki",
LastName = "mitrev",
},
ClientId = "1",
Judge = new Judge(),
Trustee = new Trustee(),
DateFiled = DateTime.UtcNow.AddDays(1),
});
dbContext.SaveChanges();
using var casesRepository = new EfDeletableEntityRepository <Case>(dbContext);
using var notesRepository = new EfDeletableEntityRepository <Note>(dbContext);
var notesService = new NotesService(notesRepository);
var casesService = new CasesService(casesRepository, notesService);
var result = casesService.GetCaseById("newId");
Assert.True(result.GetType() == typeof(CaseDetailsViewModel));
Assert.Equal("1", result.CaseNumber);
}
public ActionResult EditItems()
{
int caseid = Request.QueryString["caseid"].ToInt();
if (caseid <= 0)
{
return(RedirectToAction("Index"));
}
else
{
ViewBag.Cases = CasesService.GetCase(caseid);
return(View("EditItems"));
}
}
public void DeleteCaseById()
{
CaseViewModel mockRecord = new CaseViewModel {
CaseId = 5, LastModifiedDate = DateTime.Now, CreatedDate = DateTime.Now, Title = "title 0", Description = "test 0"
};
mockRepository.Setup(m => m.DeleteCaseById(It.IsAny <int>())).Returns(true);
var mockService = new CasesService(mockRepository.Object, mockMapper.Object);
var result = mockService.RemoveCase(mockRecord.CaseId);
mockService.Should().NotBeNull();
Assert.AreEqual(true, result);
}
public ActionResult Edit(int id)
{
ViewBag.Cases = CasesService.GetCase(id);
return(View("Edit"));
}
public CaseModel(ILogger <CaseModel> logger, CountriesService counServ, CasesService caseServ)
{
_logger = logger;
MyCountriesService = counServ;
MyCasesService = caseServ;
}
public ActionResult Delete(int id)
{
CasesService.DeleteCase(id);
return(RedirectToAction("Index"));
}
public ActionResult SaveItem(CaseItem item)
{
bool result = CasesService.SaveCaseItem(item) != null;
return(Json(result.ToString().ToLower()));
}
public ActionResult DeleteItem(int id)
{
bool result = CasesService.DeleteCaseItem(id);
return(Json(result.ToString().ToLower()));
}
public CasesController(CasesService casesService)
{
_casesService = casesService;
}
public CasesController()
{
CasesService = new CasesService(new IndividualCounselingEntities());
}
