public async Task <ActionResult> UpdateAllContractsConfirmed()
{
var allContracts = Enumerable.Empty <Contract>();
using (var dctx = new MindSageDataModelsContainer())
{
allContracts = dctx.Contracts
.Include("Licenses.CourseCatalog")
.Include("Licenses.TeacherKeys")
.ToList();
}
var canUpdateContracts = allContracts != null && allContracts.Any();
if (!canUpdateContracts)
{
return(RedirectToAction("Index"));
}
// TODO: Handle update to MongoDB error
var contractIds = allContracts.Select(it => it.Id.ToString()).Distinct();
var contractRepo = new ContractRepository();
var mongoDBcontracts = (await contractRepo.GetContractsById(contractIds)).ToList();
await updateContracts(contractRepo, allContracts, mongoDBcontracts);
await createNewContracts(contractRepo, allContracts, mongoDBcontracts);
return(RedirectToAction("Index"));
}
public ActionResult Delete(int contractId)
{
var repository = new ContractRepository();
Contracts contract = repository.GetById(contractId);
repository.Delete(contract);
return RedirectToAction("SHowContracts");
}
public IActionResult CreatePDF(string contratcIds, string request)
{
try
{
GlobalSettings globalSettings = getGlobalConfig();
ObjectSettings objectSettings = getObjectSettings();
IContractRepository Repository = new ContractRepository();
List <Contract> contratcs = Repository.GetByIdStringList(contratcIds);
objectSettings.HtmlContent = TemplateGenerator.GetHTMLString(contratcs, request);
var pdf = new HtmlToPdfDocument()
{
GlobalSettings = globalSettings,
Objects = { objectSettings }
};
_converter.Convert(pdf);
var buffer = System.IO.File.ReadAllBytes(this._PDFLocale);
return(File(buffer, "application/pdf"));
}
catch (System.Exception)
{
throw;
}
}
public InsuranceController(InsuranceRepository insuranceRepository, ContractRepository contractRepository, BranchContext branchContext, ISessionContext sessionContext)
{
_insuranceRepository = insuranceRepository;
_contractRepository = contractRepository;
_branchContext = branchContext;
_sessionContext = sessionContext;
}
public async Task <ObservableCollection <Contract> > GetContracts()
{
var repo = new ContractRepository();
var results = await repo.GetData();
return(results);
}
public static SelectList GetSelectList_Contract(object sValue)
{
var selectListItems = new List <SelectListItem>();
ContractRepository contractRepository = new ContractRepository(new Domain.Account.ErpAccountDbContext());
SelectListItem itemEmpty = new SelectListItem();
itemEmpty.Text = App_GlobalResources.Wording.Empty;
itemEmpty.Value = null;
selectListItems.Add(itemEmpty);
try
{
var q = contractRepository.GetAllContract().OrderBy(item => item.Id);
foreach (var i in q)
{
SelectListItem item = new SelectListItem();
item.Text = i.Code;
item.Value = i.Id.ToString();
selectListItems.Add(item);
}
}
catch { }
var selectList = new SelectList(selectListItems, "Value", "Text", sValue);
return(selectList);
}
public void ContractRepositoryTest()
{
ContractRepository repository = new ContractRepository();
Contract expectedContract = new Contract
{
agentId = 10,
builderId = 10,
clientId = 10,
projectId = 10
};
repository.Add(expectedContract);
Contract realContract = repository.GetAll().Last();
Assert.AreEqual(expectedContract, realContract);
repository.Delete(realContract);
realContract = repository.GetAll().Last();
Assert.AreNotEqual(expectedContract, realContract);
}
/// <summary>
/// 更新合同信息信息
/// </summary>
/// <param name="inputDtos">包含更新信息的合同信息DTO信息</param>
/// <returns>业务操作结果</returns>
public OperationResult EditContracts(params ContractInputDto[] inputDtos)
{
return(ContractRepository.Update(inputDtos,
(dto, entity) => {
if (entity.State == ContractState.Settlling || entity.State == ContractState.Finish)
{
throw new Exception("合同处于清算阶段或已结束，不能编辑");
}
},
(dto, entity) => {
if (dto.ShopId.HasValue && dto.ShopId.Value > 0)
{
Hmh.Core.Shop.Models.Shop shop = ShopRepository.GetByKey(dto.ShopId.Value);
if (shop == null)
{
throw new Exception("合同所属店铺不存在");
}
Contract usingContract = shop.Contracts.FirstOrDefault(c => c.State == ContractState.Using);
if (usingContract != null && dto.BeginTime < usingContract.EndTime)
{
throw new Exception("新合同和执行中的合同时间重合");
}
shop.CurrentContract = entity;
shop.Contracts.Add(entity);
entity.Shop = shop;
}
else
{
throw new Exception("合同没有归属店铺");
}
return entity;
}));
}
public async Task UpdateLastEmailReminderSentAndLastUpdatedAt_ReturnsNullResult_TestAsync()
{
//Arrange
int searchContractId = 99;
Contract dummyContract = null;
var mockUnitOfWork = Mock.Of <IUnitOfWork>(MockBehavior.Strict);
Mock.Get(mockUnitOfWork)
.Setup(u => u.CommitAsync())
.Returns(Task.CompletedTask)
.Verifiable();
var mockRepo = Mock.Of <IRepository <Contract> >(MockBehavior.Strict);
Mock.Get(mockRepo)
.Setup(r => r.GetByIdAsync(searchContractId))
.ReturnsAsync(dummyContract);
SetMockErrorLogger();
//Act
var contractRepo = new ContractRepository(mockRepo, mockUnitOfWork, _mockLogger.Object);
var result = await contractRepo.UpdateLastEmailReminderSentAndLastUpdatedAtAsync(searchContractId);
//Assert
result.Should().BeNull();
Mock.Get(mockRepo).Verify(r => r.GetByIdAsync(searchContractId), Times.Once);
Mock.Get(mockUnitOfWork).Verify(u => u.CommitAsync(), Times.Never);
_mockLogger.VerifyAll();
}
public void UpdateContractConfirmApprovalAsync_ReturnsContractNotFoundExceptionResult_Test()
{
//Arrange
ContractStatus requiredContractStatus = ContractStatus.ApprovedWaitingConfirmation;
ContractStatus newContractStatus = ContractStatus.Approved;
int searchContractId = 1;
Contract dummyContract = null;
var mockUnitOfWork = Mock.Of <IUnitOfWork>(MockBehavior.Strict);
Mock.Get(mockUnitOfWork)
.Setup(u => u.CommitAsync())
.Returns(Task.CompletedTask)
.Verifiable();
var mockRepo = Mock.Of <IRepository <Contract> >(MockBehavior.Strict);
Mock.Get(mockRepo)
.Setup(r => r.GetByIdAsync(searchContractId))
.ReturnsAsync(dummyContract);
SetMockErrorLogger();
//Act
var contractRepo = new ContractRepository(mockRepo, mockUnitOfWork, _mockLogger.Object);
Func <Task> act = async() => await contractRepo.UpdateContractStatusAsync(searchContractId, requiredContractStatus, newContractStatus);
//Assert
act.Should().Throw <ContractNotFoundException>();
Mock.Get(mockRepo).Verify(r => r.GetByIdAsync(searchContractId), Times.Once);
Mock.Get(mockUnitOfWork).Verify(u => u.CommitAsync(), Times.Never);
_mockLogger.VerifyAll();
}
public bool Save(Contract contract, out string strResult)
{
strResult = string.Empty;
bool result = false;
var con = ContractRepository.GetQueryable().FirstOrDefault(c => c.ContractCode == contract.ContractCode);
if (con != null)
{
try
{
con.SupplySideCode = contract.SupplySideCode;
con.DemandSideCode = contract.DemandSideCode;
con.ContractDate = contract.ContractDate;
con.StartDade = contract.StartDade;
con.EndDate = contract.EndDate;
con.SendPlaceCode = contract.SendPlaceCode;
con.SendAddress = contract.SendAddress;
con.ReceivePlaceCode = contract.ReceivePlaceCode;
con.ReceiveAddress = contract.ReceiveAddress;
con.SaleDate = contract.SaleDate;
con.State = contract.State;
ContractRepository.SaveChanges();
result = true;
}
catch (Exception ex)
{
strResult = "原因：" + ex.Message;
}
}
return(result);
}
public ContractService()
{
_ContractRepository = new ContractRepository();
_contractItemService = new ContractItemService();
_contractTypeRepository = new ShowTypeRepository();
_customerService = new CustomerService();
}
public async Task <List <ContractEntity> > ContractSearchContract(string inputParameters, DateTime startDate, DateTime endDate)
{
List <string> searchParameters = new List <string>();
if (inputParameters != null)
{
searchParameters = inputParameters.Split(' ').ToList();
}
else
{
searchParameters.DefaultContractTypesTo();
}
var contracts = await ContractRepository.ContractSearchContracts(searchParameters.ToArray(), startDate, endDate);
var contractsToReturn = contracts.Select(x => new ContractEntity()
{
ContractNumber = x.ContractNumber,
ContractUID = x.ContractUID,
EmployeeUID = x.Employee.EmployeeUID
}).ToList();
return(contractsToReturn);
}
public AgencyViewBLL()
{
AgencyRepository = new AgencyRepository();
AgencyContractRepository = new AgencyContractRepository();
ContractRepository = new ContractRepository();
QuotationRepository = new QuotationRepository();
}
public static bool MakeContract(int clientId, int agentId, int builderId, int projectId)
{
ContractRepository contractRepository = new ContractRepository();
int contractId;
try
{
contractId = contractRepository.GetAll().Last().id;
}
catch
{
contractId = 1;
contractRepository.Add(new Contract(contractId,
new ClientRepository().GetItem(clientId),
new AgentRepository().GetItem(agentId),
new BuilderRepository().GetItem(builderId),
new ProjectRepository().GetItem(projectId)));
return(true);
}
contractId = contractId + 1;
contractRepository.Add(new Contract(contractId,
new ClientRepository().GetItem(clientId),
new AgentRepository().GetItem(agentId),
new BuilderRepository().GetItem(builderId),
new ProjectRepository().GetItem(projectId)));
return(true);
}
public async Task GetByContractNumberAndVersionWithIncludesAsync_DataAndContent_ReturnsExpectedResultTest()
{
//Arrange
var expected = new Contract {
Id = 1, ContractNumber = "expected-contract-number", ContractVersion = 1, ContractContent = new ContractContent()
{
Id = 1
}, ContractData = new ContractData()
{
Id = 1
}
};
var mockUnitOfWork = Mock.Of <IUnitOfWork>(MockBehavior.Strict);
var mockRepo = Mock.Of <IRepository <Contract> >(MockBehavior.Strict);
Mock.Get(mockRepo)
.Setup(r => r.GetFirstOrDefault(It.IsAny <Expression <Func <Contract, bool> > >(), It.IsAny <Func <IQueryable <Contract>, IIncludableQueryable <Contract, object> > >()))
.ReturnsAsync(expected);
//Act
var contractRepo = new ContractRepository(mockRepo, mockUnitOfWork, _mockLogger.Object);
var actual = await contractRepo.GetByContractNumberAndVersionWithIncludesAsync(expected.ContractNumber, expected.ContractVersion, ContractDataEntityInclude.Content | ContractDataEntityInclude.Content);
//Assert
actual.Should().Be(expected);
actual.ContractContent.Should().NotBeNull();
actual.ContractData.Should().NotBeNull();
Mock.Get(mockRepo).VerifyAll();
_mockLogger.VerifyAll();
}
public static int AskBuilders()
{
var builders = new BuilderRepository().GetAll();
var contracts = new ContractRepository().GetAll();
int numberOfProjects = 0;
foreach (var builder in builders)
{
numberOfProjects = 0;
foreach (var contract in contracts)
{
try
{
if (contract.builder.id == builder.id)
{
numberOfProjects = numberOfProjects + 1;
}
}
catch
{
return(builder.id);
}
}
if (numberOfProjects < maxNumberOfProjects)
{
return(builder.id);
}
}
return(-1);
}
public async Task GetAsync_TestAsync()
{
//Arrange
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, _logger);
var expected = new DataModels.Contract
{
Id = 1,
ContractNumber = "Test",
ContractVersion = 1,
Year = "2021"
};
//Act
await repo.AddAsync(expected);
await work.CommitAsync();
var actual = await contractRepo.GetAsync(expected.Id);
//Assert
actual.Should().Be(expected);
}
public async Task CreateAsync_WhenInputIsValid_Then_CreatesContractSuccessfullyTest()
{
// Arrange
string baseUrl = $"https://localhost:5001";
SetMapperHelper();
var request = Generate_CreateContractRequest();
ILoggerAdapter <ContractService> logger = new LoggerAdapter <ContractService>(new Logger <ContractService>(new LoggerFactory()));
ILoggerAdapter <ContractRepository> loggerRepo = new LoggerAdapter <ContractRepository>(new Logger <ContractRepository>(new LoggerFactory()));
MockAuditService();
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, loggerRepo);
var uriService = new UriService(baseUrl);
var asposeDocumentManagementContractService = GetDocumentService();
var contractValidationService = GetContractValidationService();
var mediator = BuildMediator();
var contractDocumentService = BuildContractDocumentService();
var service = new ContractService(contractRepo, _mapper, uriService, logger, _mockAuditService.Object, _semaphoreOnEntity, asposeDocumentManagementContractService, contractValidationService, mediator, contractDocumentService);
// Act
var before = await contractRepo.GetByContractNumberAsync(request.ContractNumber);
await service.CreateAsync(request);
var after = await contractRepo.GetByContractNumberAsync(request.ContractNumber);
// Assert
before.Should().BeEmpty();
after.Should().HaveCount(1).And.Subject.First().ContractVersion.Should().Be(request.ContractVersion);
}
public ActionResult ShowContracts()
{
ContractRepository repository = new ContractRepository();
var contractsToShow = new List <ShowContractModel>();
var contracts = repository.GetAll();
foreach (var contract in contracts)
{
contractsToShow.Add
(
new ShowContractModel
{
agentName = contract.Agents.name,
builderName = contract.Builders.name,
clientName = contract.Clients.name,
ContractId = contract.id,
projectDescription = contract.Projects.description,
projectName = contract.Projects.name,
projectDeadLine = contract.Projects.deadline
}
);
}
return(View(contractsToShow));
}
private void radGridView3_UserDeletingRow(object sender, GridViewRowCancelEventArgs e)
{
DialogResult result = MessageBox.Show("آیا از عملیات حذف مطمئن هستید؟", "هشدار", MessageBoxButtons.YesNo);
if (result == DialogResult.No)
{
e.Cancel = true;
}
else
{
int value = 0;
DefaultSettingsRepository dRepo = new DefaultSettingsRepository();
ContractRepository cRepo = new ContractRepository();
AppointmentRepository rep = new AppointmentRepository();
int appointmentId = Convert.ToInt32(radGridView3.SelectedRows[0].Cells[0].Value.ToString());
Appointment appo = rep.getAppointment(appointmentId);
string[] parts = appo.Description.Split('/');
foreach (string part in parts)
{
DefaultSetting ds = dRepo.GetSetting(part);
value += Convert.ToInt32(ds.Value);
}
Contract contract = cRepo.getContract(appo.ContractId.Value);
contract.ContractPayment -= value;
cRepo.updateContract(contract);
rep.deleteAppointment(appointmentId);
ContractRepository repository = new ContractRepository();
radGridView1.DataSource = repository.getContractsByCustomerId(customerId).ToList();
}
}
public static bool MakeContract(int clientId, int agentId, int builderId, int projectId)
{
ContractRepository contractRepository = new ContractRepository();
int contractId;
try
{
contractId = contractRepository.GetAll().Last().id;
}
catch
{
contractId = 1;
contractRepository.Add( new Contract(contractId,
new ClientRepository().GetItem(clientId),
new AgentRepository().GetItem(agentId),
new BuilderRepository().GetItem(builderId),
new ProjectRepository().GetItem(projectId)));
return true;
}
contractId = contractId + 1;
contractRepository.Add(new Contract(contractId,
new ClientRepository().GetItem(clientId),
new AgentRepository().GetItem(agentId),
new BuilderRepository().GetItem(builderId),
new ProjectRepository().GetItem(projectId)));
return true;
}
public async Task <IActionResult> UpdateStatus(int id, short isActive)
{
ResponseHelper objHelper = new ResponseHelper();
if (!ModelState.IsValid)
{
objHelper.Status = 410;
objHelper.Message = "Invalid Model State";
return(BadRequest(objHelper));
}
try
{
await ContractRepository.ToogleStatus(id, isActive);
objHelper.Status = StatusCodes.Status200OK;
objHelper.Message = "Saved Successfully";
objHelper.Data = await ContractRepository.Get(id);
return(Ok(objHelper));
}
catch
{
objHelper.Status = StatusCodes.Status500InternalServerError;
objHelper.Message = "Save Unsuccessful";
return(StatusCode(StatusCodes.Status500InternalServerError, objHelper));
}
}
public override void ProcessComplited(Guid documentId, EXP_Activities activity)
{
var contractRepository = new ContractRepository(_context);
contractRepository.SendToRegistration(documentId);
_context.SaveChanges();
}
public async Task UpdateLastEmailReminderSentAndLastUpdatedAtAsync_Test()
{
//Arrange
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, _logger);
int contractId = 1;
const string contractNumber = "main-0001";
const string title = "Test Title";
DateTime lastEmailReminderSent = DateTime.UtcNow;
var working = new List <DataModels.Contract>
{
new DataModels.Contract {
Id = contractId, Title = title, ContractNumber = contractNumber, ContractVersion = 1, Ukprn = 12345678, LastEmailReminderSent = null, LastUpdatedAt = lastEmailReminderSent
}
};
foreach (var item in working)
{
await repo.AddAsync(item);
}
await work.CommitAsync();
await contractRepo.UpdateLastEmailReminderSentAndLastUpdatedAtAsync(contractId);
//Act
var actual = await contractRepo.GetAsync(contractId);
//Assert
actual.LastEmailReminderSent.Should().NotBeNull();
}
public async Task ExampleCreateContractAsync_TestAsync()
{
//Arrange
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, _logger);
var contract = new DataModels.Contract
{
Id = 1,
ContractNumber = "Test",
ContractVersion = 1,
Year = "2021"
};
//Act
var before = await repo.GetByIdAsync(1);
await contractRepo.CreateAsync(contract);
var after = await repo.GetByIdAsync(1);
//Assert
before.Should().BeNull();
after.Should().BeEquivalentTo(contract);
}
public async Task <InsertResponse> GenerateContractsAsync(GenerateItemsRequest request)
{
var patientIds = await UserManager.GetUsersIdAsync(new UsersIdRequest
{
Amount = request.Count,
UserType = UserType.Patient
});
var doctorIds = await UserManager.GetUsersIdAsync(new UsersIdRequest
{
Amount = request.Count,
UserType = UserType.Doctor
});
var familyMemberIds = await UserManager.GetUsersIdAsync(new UsersIdRequest
{
Amount = request.Count,
UserType = UserType.FamilyMember
});
var contracts = new Faker <Contract>()
.RuleFor(u => u.Id, f => ObjectId.GenerateNewId().ToString())
.RuleFor(bp => bp.PatientId, f => f.PickRandom(patientIds))
.RuleFor(bp => bp.DoctorId, f => f.PickRandom(doctorIds))
.RuleFor(bp => bp.FamilyMemberId, f => f.PickRandom(familyMemberIds))
.Generate(request.Count).ToList();
return(await ContractRepository.BulkInsertContractAsync(contracts));
}
public async Task GetByContractNumberAsync_TestAsync()
{
//Arrange
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, _logger);
const string ContractNumber = "Test";
var expected = new List <DataModels.Contract>
{
new DataModels.Contract {
Id = 1, ContractNumber = ContractNumber, ContractVersion = 1
},
new DataModels.Contract {
Id = 2, ContractNumber = ContractNumber, ContractVersion = 2
},
new DataModels.Contract {
Id = 3, ContractNumber = ContractNumber, ContractVersion = 3
},
};
foreach (var item in expected)
{
await repo.AddAsync(item);
}
await work.CommitAsync();
//Act
var actual = await contractRepo.GetByContractNumberAsync(ContractNumber);
//Assert
actual.Should().BeEquivalentTo(expected);
}
private void bSave_Click(object sender, EventArgs e)
{
PersianDateFormatter pdf = new PersianDateFormatter();
AppointmentRepository appRepo = new AppointmentRepository();
ContractRepository cRepo = new ContractRepository();
Contract contract = cRepo.getContract(contractId);
Appointment app = new Appointment();
string description = "";
int value = 0;
foreach (var item in radCheckedDropDownList1.CheckedItems)
{
description += item.DisplayValue.ToString() + "/";
value += Convert.ToInt32(item.Value);
}
contract.ContractPayment += value;
cRepo.updateContract(contract);
app.ContractId = contractId;
description = description.Remove(description.Length - 1);
app.Description = description;
app.AppointmentDate = pdf.convert(tDate.Text);
TimeSpan ts = new TimeSpan(tTime.Value.TimeOfDay.Hours, tTime.Value.TimeOfDay.Minutes, 0);
app.AppointmentTime = ts;
appRepo.addAppointment(app);
}
public async Task <IActionResult> Edit(ContractView contract)
{
ResponseHelper objHelper = new ResponseHelper();
if (!ModelState.IsValid)
{
objHelper.Status = StatusCodes.Status424FailedDependency;
objHelper.Message = "Invalid Model State";
return(BadRequest(objHelper));
}
try
{
if (ContractRepository.Exists(contract))
{
objHelper.Status = StatusCodes.Status200OK;
objHelper.Message = "Data already available";
return(Ok(objHelper));
}
await ContractRepository.Update(contract);
objHelper.Status = StatusCodes.Status200OK;
objHelper.Message = "Saved Successfully";
return(Ok(objHelper));
}
catch
{
objHelper.Status = StatusCodes.Status500InternalServerError;
objHelper.Message = "Save Unsuccessful";
return(StatusCode(StatusCodes.Status500InternalServerError, objHelper));
}
}
public async Task <IActionResult> Get(int id)
{
ResponseHelper objHelper = new ResponseHelper();
try
{
var vList = await ContractRepository.Get(id);
if (vList == null)
{
objHelper.Status = StatusCodes.Status200OK;
objHelper.Message = "Get Empty Data";
}
else
{
objHelper.Status = StatusCodes.Status200OK;
objHelper.Message = "Get Successfully";
objHelper.Data = vList;
}
return(Ok(objHelper));
}
catch
{
objHelper.Status = StatusCodes.Status500InternalServerError;
objHelper.Message = "Get Unsuccessful";
return(StatusCode(StatusCodes.Status500InternalServerError, objHelper));
}
}
public async Task <IActionResult> FindPagination(Pagination pagination)
{
ResponseHelper objHelper = new ResponseHelper();
try
{
pagination.RecordCount = ContractRepository.RecordCount(pagination.CommonSearch);
var vList = await ContractRepository.FindPaginated(pagination.PageIndex, pagination.PageSize, pagination.CommonSearch);
if (vList == null)
{
objHelper.Status = StatusCodes.Status200OK;
objHelper.Message = "Get Empty Data";
}
else
{
objHelper.Status = StatusCodes.Status200OK;
objHelper.Message = "Get Successfully";
objHelper.Data = vList;
}
return(Ok(objHelper));
}
catch
{
objHelper.Status = StatusCodes.Status500InternalServerError;
objHelper.Message = "Get Unsuccessful";
return(StatusCode(StatusCodes.Status500InternalServerError, objHelper));
}
}
public static int AskBuilders()
{
var builders = new BuilderRepository().GetAll();
var contracts = new ContractRepository().GetAll();
int numberOfProjects = 0;
foreach (var builder in builders)
{
numberOfProjects = 0;
foreach (var contract in contracts)
{
try
{
if (contract.builder.id == builder.id)
{
numberOfProjects = numberOfProjects + 1;
}
}
catch
{
return builder.id;
}
}
if (numberOfProjects < maxNumberOfProjects)
{
return builder.id;
}
}
return -1;
}
static void ShowContracts()
{
var contracts = new ContractRepository().GetAll();
Console.CursorLeft = 0;
Console.CursorTop = 0;
foreach (var contract in contracts)
{
Console.WriteLine(contract.ToString());
}
Console.WriteLine(contracts.Count());
}
public UnitOfWork(ContaContext context)
{
_mContext = context;
Lucrari = new LucrareRepository(_mContext);
Beneficiari = new BeneficiarRepository(_mContext);
AcceptateRespinse = new AcceptatRefuzataRepository(_mContext);
TipLucrare = new TipLucrareRepository(_mContext);
ReceptionateRespinse = new ReceprionataRespinsaRepository(_mContext);
Contracte = new ContractRepository(_mContext);
TipActe = new TipActRepository(_mContext);
Incasari = new IncasareRepository(_mContext);
Plati = new PlataRepository(_mContext);
}
public static bool MakeContract(int clientId, int agentId, int builderId, int projectId)
{
ContractRepository contractRepository = new ContractRepository();
Contract contract = new Contract();
contract.agentId = agentId;
contract.clientId = clientId;
contract.builderId = builderId;
contract.projectId = projectId;
contractRepository.Add(contract);
return true;
}
static void CheckContracts()
{
var projects = new ProjectRepository().GetAll();
ContractRepository contractRepository = new ContractRepository();
foreach (var project in projects)
{
if (project.id == 0)
return;
if (project.deadLine < DateTime.Now)
{
var contracts = contractRepository.GetAll().ToArray();
var variable = contracts.Where(contract => contract.project.id == project.id).First();
contractRepository.Delete(variable);
new ProjectRepository().Delete(project);
}
}
}
static void ShowContracts()
{
var contracts = new ContractRepository().GetAll();
ProjectRepository projectRepository = new ProjectRepository();
Console.WriteLine("************************************");
//Console.CursorLeft = 0;
//Console.CursorTop = 0;
foreach (var contract in contracts)
{
Console.WriteLine("Contract №{0}", contract.id);
Console.WriteLine(" Client's name: {0}", new ClientRepository().GetItem(contract.clientId).name);
Console.WriteLine(" Builder's name: {0}", new BuilderRepository().GetItem(contract.builderId).name);
Console.WriteLine(" Agent's name: {0}", new AgentRepository().GetItem(contract.agentId).name);
Console.WriteLine(" Project's name: {0}", projectRepository.GetItem(contract.projectId).name);
Console.WriteLine(" Project's deadLine: {0}", projectRepository.GetItem(contract.projectId).deadLine);
}
Console.WriteLine(contracts.Count());
}
static void CheckContracts()
{
ContractRepository contractRepository = new ContractRepository();
ProjectRepository projectRepository = new ProjectRepository();
var projects = projectRepository.GetAll();
foreach (var project in projects)
{
if (project.id == 0)
return;
if (project.deadLine < DateTime.Now)
{
var contractToDelete = contractRepository.GetAll().
Where(contract => contract.projectId == project.id).First();
contractRepository.Delete(contractToDelete);
projectRepository.Delete(project);
}
}
}
public void ContractRepositoryTest()
{
ContractRepository repository = new ContractRepository();
Contract expectedContract = new Contract
{
agentId = 10,
builderId = 10,
clientId = 10,
projectId = 10
};
repository.Add(expectedContract);
Contract realContract = repository.GetAll().Last();
Assert.AreEqual(expectedContract, realContract);
repository.Delete(realContract);
realContract = repository.GetAll().Last();
Assert.AreNotEqual(expectedContract, realContract);
}
public ActionResult ShowContracts()
{
ContractRepository repository = new ContractRepository();
var contractsToShow = new List<ShowContractModel>();
var contracts = repository.GetAll();
foreach (var contract in contracts)
{
contractsToShow.Add
(
new ShowContractModel
{
agentName = contract.Agents.name,
builderName = contract.Builders.name,
clientName = contract.Clients.name,
ContractId = contract.id,
projectDescription = contract.Projects.description,
projectName = contract.Projects.name,
projectDeadLine = contract.Projects.deadline
}
);
}
return View(contractsToShow);
}
