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 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); }