public async Task <HmmNote> UpdateAsync(HmmNote entity) { Guard.Against <ArgumentNullException>(entity == null, nameof(entity)); try { // check if need apply default catalog // ReSharper disable once PossibleNullReferenceException var catalog = PropertyChecking(entity.Catalog); entity.Catalog = catalog ?? throw new Exception("Cannot find default note catalog."); entity.LastModifiedDate = DateTimeProvider.UtcNow; DataContext.Notes.Update(entity); await DataContext.SaveAsync(); var savedRec = LookupRepo.GetEntity <HmmNote>(entity.Id); return(savedRec); } catch (Exception ex) { ProcessMessage.WrapException(ex); return(null); } }
public PaymentController() { _PaymentRepo = new PaymentRepo(ConnString); _WorkRepo = new WorkRepo(ConnString); _JobRepo = new JobRepo(ConnString); _LookupRepo = new LookupRepo(ConnString); }
public void Cannot_Update_Invalid_Note() { // Arrange var note = new HmmNote { Author = _user, Description = "testing note", Subject = "testing note is here", Content = "<root><time>2017-08-01</time></root>" }; CurrentTime = new DateTime(2021, 4, 4, 8, 15, 0); _manager.Create(note); Assert.True(_manager.ProcessResult.Success); var savedRec = NoteRepository.GetEntities().FirstOrDefault(); Assert.NotNull(savedRec); Assert.Equal("jfang", savedRec.Author.AccountName); // change the note render var newUser = LookupRepo.GetEntities <Author>().FirstOrDefault(u => u.AccountName != "jfang"); Assert.NotNull(newUser); note.Author = newUser; _testValidator.GetInvalidResult = true; // Act savedRec = _manager.Update(note); // Assert Assert.False(_manager.ProcessResult.Success); Assert.Null(savedRec); Assert.False(note.IsDeleted); }
public IActionResult Index(LookupViewModel vm, string buttonValue) { switch (buttonValue) { case "Save": if (ModelState.IsValid) { vm.EditLookup.GroupId = vm.SelectedGroupId; LookupRepo.SaveLookup(vm.EditLookup); vm.EditLookup = new TimeCard.Domain.Lookup(); ModelState.Clear(); } break; case "Delete": LookupRepo.DeleteLookup(vm.EditLookup.Id); break; default: vm.EditLookup = new TimeCard.Domain.Lookup(); ModelState.Clear(); break; } prepIndex(vm); return(View(vm)); }
private void SetupTestEnv() { InsertSeedRecords(); _user = LookupRepo.GetEntities <Author>().FirstOrDefault(); _validator = new NoteValidator(NoteRepository); _manager = new HmmNoteManager(NoteRepository, _validator, DateProvider); }
private IEnumerable <SelectListItem> GetLookup(string group) { return(LookupRepo.GetLookups(group, "- Select -").Where(x => x.Id == 0 || x.Active == true) .Select(x => new SelectListItem { Text = x.Descr, Value = x.Id.ToString() })); }
public NoteRender Update(NoteRender entity) { Guard.Against <ArgumentNullException>(entity == null, nameof(entity)); // ReSharper disable once PossibleNullReferenceException if (entity.Id <= 0) { ProcessMessage.Success = false; ProcessMessage.AddErrorMessage($"Can not update NoteRender with id {entity.Id}", true); return(null); } try { // make sure the record exists in data source DataContext.Renders.Update(entity); DataContext.Save(); return(LookupRepo.GetEntity <NoteRender>(entity.Id)); } catch (Exception ex) { ProcessMessage.WrapException(ex); return(null); } }
public async Task <Subsystem> UpdateAsync(Subsystem entity) { Guard.Against <ArgumentNullException>(entity == null, nameof(entity)); // ReSharper disable once PossibleNullReferenceException if (entity.Id <= 0) { ProcessMessage.Success = false; ProcessMessage.AddErrorMessage($"Can not update Subsystem with id {entity.Id}", true); return(null); } try { // make sure the record exists in data source DataContext.Subsystems.Update(entity); await DataContext.SaveAsync(); return(LookupRepo.GetEntity <Subsystem>(entity.Id)); } catch (Exception ex) { ProcessMessage.WrapException(ex); return(null); } }
protected TP PropertyChecking <TP>(TP property) where TP : HasDefaultEntity { var defaultNeeded = false; if (property == null) { defaultNeeded = true; } else if (property.Id <= 0) { defaultNeeded = true; } else if (LookupRepo.GetEntity <TP>(property.Id) == null) { defaultNeeded = true; } if (!defaultNeeded) { return(property); } var defaultProp = LookupRepo.GetEntities <TP>(p => p.IsDefault).FirstOrDefault(); return(defaultProp); }
public ActionResult GenerateDocs(int contractorId, int cycle) { var templateFile = new FileInfo($"{WebRootPath}\\Content\\TimeCardTemplates.xlsx"); try { string name = LookupRepo.GetLookups("Contractor").Where(x => x.Id == contractorId).FirstOrDefault()?.Descr; var fileList = new List <string>(); GenerateTimeCards(contractorId, name, templateFile, cycle, fileList); GenerateTimeBooks(contractorId, name, templateFile, cycle, fileList); GenerateInvoices(contractorId, name, templateFile, cycle, fileList); GenerateSummary(contractorId, name, templateFile, cycle, fileList); if (!fileList.Any()) { return(Json(new { success = false, message = "Nothing to generate." })); } string zipFile = $"C:\\TEMP\\{name}.zip"; TempData["Download"] = JsonConvert.SerializeObject(new Infrastructure.ZipDownload { FileName = zipFile, FileList = fileList }); return(Json(new { success = true })); } catch (Exception ex) { return(Json(new { success = false, message = ex.Message })); } }
public void CannotChangeAuthorForExistsNote() { // Arrange var note = new HmmNote { Author = _user, Description = "testing note", Subject = "testing note is here", Content = "<root><time>2017-08-01</time></root>", Catalog = new NoteCatalog() }; CurrentTime = new DateTime(2021, 4, 4, 8, 15, 0); _manager.Create(note); Assert.True(_manager.ProcessResult.Success); var savedRec = NoteRepository.GetEntities().FirstOrDefault(); Assert.NotNull(savedRec); Assert.Equal("jfang", savedRec.Author.AccountName); // change the note render var newUser = LookupRepo.GetEntities <Author>().FirstOrDefault(u => u.AccountName != "jfang"); Assert.NotNull(newUser); note.Author = newUser; // Act var processResult = new ProcessingResult(); var result = _validator.IsValidEntity(note, processResult); // Assert Assert.False(result); }
public PaymentController(IConfiguration config, IWebHostEnvironment webHostEnvironment, IHttpContextAccessor httpContextAccessor) : base(config, webHostEnvironment, httpContextAccessor) { _PaymentRepo = new PaymentRepo(ConnString); _WorkRepo = new WorkRepo(ConnString); _JobRepo = new JobRepo(ConnString); _LookupRepo = new LookupRepo(ConnString); }
public NoteCatalog Update(NoteCatalog entity) { Guard.Against <ArgumentNullException>(entity == null, nameof(entity)); // ReSharper disable once PossibleNullReferenceException if (entity.Id <= 0) { ProcessMessage.Success = false; ProcessMessage.AddErrorMessage($"Can not update NoteCatalog with id {entity.Id}", true); return(null); } try { // check if need apply default render var render = PropertyChecking(entity.Render); const string message = "Cannot find default note render."; ProcessMessage.Success = false; ProcessMessage.AddErrorMessage(message, true); entity.Render = render ?? throw new DataSourceException(message); DataContext.Catalogs.Update(entity); DataContext.Save(); return(LookupRepo.GetEntity <NoteCatalog>(entity.Id)); } catch (Exception ex) { ProcessMessage.WrapException(ex); return(null); } }
/// <summary> /// The asynchronous version of <see cref="GetNotes"/> /// </summary> /// <param name="entity">The entity which used to get type and figure out the catalog</param> /// <param name="resourceCollectionParameters">The page information of the resource collection</param> /// <returns>The notes which belongs to entity type</returns> protected async Task <PageList <HmmNote> > GetNotesAsync(T entity, Expression <Func <HmmNote, bool> > query = null, ResourceCollectionParameters resourceCollectionParameters = null) { var catId = await entity.GetCatalogIdAsync(LookupRepo); var author = await LookupRepo.GetEntityAsync <Author>(DefaultAuthor.Id); var hasValidAuthor = DefaultAuthor != null && author != null; switch (hasValidAuthor) { case false: ProcessResult.AddErrorMessage("Cannot find default author", true); return(null); default: PageList <HmmNote> notes; if (query != null) { var finalExp = query.And(n => n.Author.Id == DefaultAuthor.Id && n.Catalog.Id == catId); notes = await NoteManager.GetNotesAsync(finalExp, false, resourceCollectionParameters); } else { notes = await NoteManager.GetNotesAsync(n => n.Author.Id == DefaultAuthor.Id && n.Catalog.Id == catId, false, resourceCollectionParameters); } return(notes); } }
/// <summary> /// Get notes for specific entity /// </summary> /// <param name="id">The id of entity to get type and figure out the catalog</param> /// <param name="entity">The entity by id which used to get type and figure out the catalog</param> /// <returns>The notes which belongs to entity type</returns> protected async Task <HmmNote> GetNoteAsync(int id, T entity) { var catId = await entity.GetCatalogIdAsync(LookupRepo); var hasValidAuthor = DefaultAuthor != null && LookupRepo.GetEntity <Author>(DefaultAuthor.Id) != null; switch (hasValidAuthor) { case false: ProcessResult.AddErrorMessage("Cannot find default author", true); return(null); default: var note = await NoteManager.GetNoteByIdAsync(id); if (note == null) { return(null); } if (note.Author.Id == DefaultAuthor.Id && note.Catalog.Id == catId) { return(note); } return(null); } }
private void prepWork(Models.WorkViewModel vm, bool clearEdit = false) { var cycles = GetPayCycles(); int cycle = int.Parse(cycles.First().Value); vm.WorkTypes = LookupRepo.GetLookups("WorkType", "- Select -").Select(x => new SelectListItem { Text = x.Descr, Value = x.Id.ToString() }); vm.PayCycles = cycles; vm.IsCycleOpen = false; vm.CanCloseCycle = true; if (vm.SelectedCycle == 0) { vm.SelectedCycle = cycle; } if (vm.SelectedCycle == cycle) { vm.IsCycleOpen = true; vm.CanCloseCycle = false; } vm.Jobs = _JobRepo.GetJobsForWork(vm.SelectedContractorId, vm.SelectedCycle).Select(x => new SelectListItem { Text = x.Descr, Value = x.Id.ToString() }); vm.WorkEntries = _WorkRepo.GetWork(vm.SelectedContractorId, vm.SelectedCycle, true); if (vm.SortByJob) { vm.WorkEntries = vm.WorkEntries.OrderBy(x => x.Job).ThenBy(x => x.WorkDay); } if (vm.EditWork == null) { vm.EditWork = new TimeCard.Domain.Work { ContractorId = vm.SelectedContractorId, WorkDay = DateRef.GetWorkDay(DateTime.Today) }; } if (clearEdit) { vm.EditWork = new TimeCard.Domain.Work { ContractorId = vm.SelectedContractorId, WorkDay = vm.EditWork.WorkDay, JobId = vm.EditWork.JobId, WorkType = vm.EditWork.WorkType }; } vm.EditDays = GetEditDays(vm.SelectedCycle); vm.DailyTotals = new decimal[2][]; for (int i = 0; i < 2; i++) { vm.DailyTotals[i] = new decimal[8]; for (int j = 0; j < 7; j++) { vm.DailyTotals[i][j] = vm.WorkEntries.Where(x => x.WeekDay == j + i * 7).Sum(x => x.Hours); vm.DailyTotals[i][7] += vm.DailyTotals[i][j]; } } if (!vm.IsCycleOpen) { vm.IsCycleOpen = _WorkRepo.GetWorkOpen(vm.SelectedContractorId).Any(x => x == vm.SelectedCycle); } }
public ActionResult Index() { int contractorId = LookupRepo.GetLookupByVal("Contractor", CurrentUsername).Id; var jobs = _JobRepo.GetJobStart(contractorId); return(View(new ViewModels.JobViewModel { ContractorId = contractorId, Jobs = jobs })); }
private IApplication GetApplication() { var user = LookupRepo.GetEntities <Author>().FirstOrDefault(); var system = new Subsystem { DefaultAuthor = user, }; var fakeApplication = new Mock <IApplication>(); fakeApplication.Setup(app => app.GetApplication(LookupRepo)).Returns(system); fakeApplication.Setup(app => app.GetCatalog(It.IsAny <NoteCatalogType>(), It.IsAny <IEntityLookup>())).Returns((NoteCatalogType type, IEntityLookup lookupRepo) => { NoteCatalog catalog; switch (type) { case NoteCatalogType.Automobile: catalog = LookupRepo.GetEntities <NoteCatalog>() .FirstOrDefault(c => c.Name == AutomobileConstant.AutoMobileInfoCatalogName); if (catalog != null) { var schemaStr = File.ReadAllText("Automobile.xsd"); catalog.Schema = schemaStr; } break; case NoteCatalogType.GasDiscount: catalog = LookupRepo.GetEntities <NoteCatalog>() .FirstOrDefault(c => c.Name == AutomobileConstant.GasDiscountCatalogName); if (catalog != null) { var schemaStr = File.ReadAllText("Discount.xsd"); catalog.Schema = schemaStr; } break; case NoteCatalogType.GasLog: catalog = LookupRepo.GetEntities <NoteCatalog>() .FirstOrDefault(c => c.Name == AutomobileConstant.GasLogCatalogName); if (catalog != null) { var schemaStr = File.ReadAllText("GasLog.xsd"); catalog.Schema = schemaStr; } break; default: catalog = null; break; } return(catalog); }); return(fakeApplication.Object); }
void prepIndex(LookupViewModel vm) { vm.LookupGroups = LookupRepo.GetGroups().Select(x => new Microsoft.AspNetCore.Mvc.Rendering.SelectListItem { Value = x.GroupId.ToString(), Text = x.Descr }); if (vm.SelectedGroupId != 0) { vm.Lookups = LookupRepo.GetLookups(vm.SelectedGroupId); } }
public ActionResult Index() { var vm = new ViewModels.WorkViewModel { Contractor = LookupRepo.GetLookupByVal("Contractor", CurrentUsername) }; Session["Contractor"] = vm.Contractor; prepWork(vm); return(View(vm)); }
public void Can_Update_Subsystem() { // Arrange Assert.NotNull(_author); var sys = new Subsystem { Name = "Test Subsystem", DefaultAuthor = _author, Description = "Default Subsystem", NoteCatalogs = new List <NoteCatalog> { new() { Name = "Test Catalog1", Schema = "Test Catalog1 Schema", Render = new NoteRender { Name = "Test Catalog1 Render", Namespace = "Hmm.Render", Description = "This is description of test catalog1 render" } }, new () { Name = "Test Catalog2", Schema = "Test Catalog2 Schema", Render = new NoteRender { Name = "Test Catalog2 Render", Namespace = "Hmm.Render", Description = "This is description of test catalog2 render" } } } }; var newSys = SubsystemRepository.Add(sys); var savedSys = LookupRepo.GetEntities <Subsystem>().FirstOrDefault(s => s.Id == newSys.Id); Assert.NotNull(savedSys); // Act savedSys.Description = "changed default Subsystem"; var firstCatalog = savedSys.NoteCatalogs.First(); Assert.NotNull(firstCatalog); firstCatalog.Name = "Updated Test Catalog1"; firstCatalog.Render.Name = "Update Test Catalog1 Render Name"; var updatedSys = SubsystemRepository.Update(savedSys); // Assert Assert.NotNull(updatedSys); Assert.Equal("changed default Subsystem", updatedSys.Description); Assert.True(SubsystemRepository.ProcessMessage.Success); }
private void SetupTestEnv() { InsertSeedRecords(); _user = LookupRepo.GetEntities <Author>().FirstOrDefault(); var schemaStr = File.ReadAllText("NotebaseSchema.xsd"); var catalog = new NoteCatalog { Schema = schemaStr }; _noteSerializer = new TestDefaultXmlNoteSerializer(new NullLogger <HmmNote>(), catalog); }
private void SetupDevEnv() { InsertSeedRecords(); var catalog = LookupRepo.GetEntities <NoteCatalog>() .FirstOrDefault(c => c.Name == AutomobileConstant.GasDiscountCatalogName); Assert.NotNull(catalog); var noteSerializer = new GasDiscountXmlNoteSerializer(Application, new NullLogger <GasDiscount>(), LookupRepo); var noteManager = new HmmNoteManager(NoteRepository, new NoteValidator(NoteRepository), DateProvider); _manager = new DiscountManager(noteSerializer, new GasDiscountValidator(LookupRepo), noteManager, LookupRepo); _authorId = ApplicationRegister.DefaultAuthor.Id; }
private void SetupDevEnv() { InsertSeedRecords(); // add testing note catalog var catalog = LookupRepo.GetEntities <NoteCatalog>() .FirstOrDefault(c => c.Name == AutomobileConstant.AutoMobileInfoCatalogName); Assert.NotNull(catalog); var noteSerializer = new AutomobileXmlNoteSerializer(Application, new NullLogger <AutomobileInfo>(), LookupRepo); var noteManager = new HmmNoteManager(NoteRepository, new NoteValidator(NoteRepository), DateProvider); _manager = new AutomobileManager(noteSerializer, new AutomobileValidator(LookupRepo), noteManager, LookupRepo); }
public void Can_Check_Author_Exists(string authorId, bool expected) { // Arrange var id = authorId; if (authorId == "FirstID") { id = LookupRepo.GetEntities <Author>().FirstOrDefault()?.Id.ToString(); } // Act var result = _authorManager.AuthorExists(id); // Assert Assert.Equal(result, expected); }
public void Dispose() { if (_dbContext is DbContext context) { context.Reset(); } var systems = LookupRepo.GetEntities <Subsystem>().ToList(); foreach (var sys in systems) { SubsystemRepository.Delete(sys); } var notes = LookupRepo.GetEntities <HmmNote>().ToList(); foreach (var note in notes) { NoteRepository.Delete(note); } var catalogs = LookupRepo.GetEntities <NoteCatalog>().ToList(); foreach (var catalog in catalogs) { CatalogRepository.Delete(catalog); } var renders = LookupRepo.GetEntities <NoteRender>().ToList(); foreach (var render in renders) { RenderRepository.Delete(render); } var authors = LookupRepo.GetEntities <Author>().ToList(); foreach (var author in authors) { AuthorRepository.Delete(author); } if (_dbContext is DbContext newContext) { newContext.Reset(); } GC.SuppressFinalize(this); }
public override bool IsValid(HmmNote entity, bool isNewEntity) { if (entity == null) { ValidationErrors.Add("Error: null note found."); return(false); } // make sure note author is exists if (isNewEntity) { if (!IsAuthorValid(entity.Author)) { return(false); } } if (!isNewEntity) { if (entity.Id <= 0) { ValidationErrors.Add($"The note get invalid id {entity.Id}"); return(false); } var rec = LookupRepo.GetEntity <HmmNote>(entity.Id); if (rec == null) { ValidationErrors.Add($"Cannot find note with id {entity.Id} from data source"); return(false); } // check if user want to update author for note which does not allowed by system var newAuthorId = entity.Author.Id; if (rec.Author.Id != newAuthorId) { ValidationErrors.Add($"Cannot update note: {entity.Id}'s author. current author id: {rec.Id}, new author id: {newAuthorId}"); return(false); } } return(true); }
private bool IsAuthorValid(User author) { // make sure note author is exists if (author == null || author.Id <= 0) { ValidationErrors.Add("Error: invalid author attached to note."); return(false); } var savedAuthor = LookupRepo.GetEntity <User>(author.Id); if (savedAuthor == null) { ValidationErrors.Add("Error: cannot find author from data source."); return(false); } return(true); }
public async Task <PageList <NoteRender> > GetEntitiesAsync(Expression <Func <NoteRender, bool> > query = null, ResourceCollectionParameters resourceCollectionParameters = null) { var renders = await LookupRepo.GetEntitiesAsync(query, resourceCollectionParameters); return(renders); }
public PageList <NoteRender> GetEntities(Expression <Func <NoteRender, bool> > query = null, ResourceCollectionParameters resourceCollectionParameters = null) { return(LookupRepo.GetEntities(query, resourceCollectionParameters)); }