public async Task Create([FromBody] SemesterDto semester) { await _commandDispatcher.Dispatch <CreateSemester.Command>(new CreateSemester.Command() { semester = semester }); }
public void ProcessClassList(UserFile userFile, SemesterDto semester) { // System.Console.WriteLine($"userFile StorageFileName: {userFile.StorageFileName} semester id: {semester.Id}"); //using (var reader = new StreamReader("path\\to\\file.csv")) using (var reader = new StreamReader(userFile.FilePath)) using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture)) { //csv.Configuration.PrepareHeaderForMatch = (string header, int index) => header.ToLower(); var records = csv.GetRecords <ClassListDto>(); foreach (var record in records.ToList()) { var props = record.GetType().GetProperties(); // var sb = new StringBuilder(); foreach (var p in props) { System.Console.WriteLine(p.Name + ": " + p.GetValue(record, null)); // sb.AppendLine(p.Name + ": " + p.GetValue(obj, null)); } System.Console.WriteLine("!!!" + record.MAJOR); // return sb.ToString(); } } }
public async Task <ActionResult <SemesterDto> > PostSemester(SemesterDto semester) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } SemesterDto semesterDto; try { semesterDto = await semesterService.CreateSemesterAsync(semester, User.Identity.Name); if (semesterDto != null) { this.RemoveCache(CacheKeys.Semester); } } catch (Exception ex) { return(BadRequest(ex.Message)); } // var semesterDto = await _context.Semesters.Select(SemesterDto.AsSemesterDto).SingleOrDefaultAsync(m => m.Id == semester.Id); return(CreatedAtAction("GetSemester", new { id = semesterDto.Id }, semesterDto)); }
private Semester _addSemesterToRepo(SemesterDto semester) { var newSemester = _mapper.Map <Semester>(semester); _semesterScheduleUnitOfWork.Repository.Add(newSemester); return(newSemester); }
public async Task <SemesterDto> CreateGroupSemesterAsync(SemesterDto semester) { var newSemester = _addSemesterToRepo(semester); await _semesterScheduleUnitOfWork.SaveChangesAsync().ConfigureAwait(false); return(await GetGroupSemesterAsync(newSemester.Id).ConfigureAwait(false)); }
public async Task <IEnumerable <Semester> > PostAddSemester(SemesterDto semesterDto) { _logger.Debug($"Szemeszter hozzáadása következik: {semesterDto}"); await _evoNaploContext.Semesters.AddAsync(new Semester(semesterDto.StartDate, semesterDto.EndDate, semesterDto.DemoDate)); _evoNaploContext.SaveChanges(); _logger.Debug($"Szemeszter hozzáadva"); return(_evoNaploContext.Semesters.ToList()); }
public async Task <IActionResult> Update([FromBody] SemesterDto dto) { var result = await _semesterService.UpdateAsync(dto); if (result == null) { return(NotFound()); } return(Ok(result)); }
public async Task <SemesterDto> CreateSemester(SemesterDto semesterDto) { var semester = new Semester(); _mapper.Map(semesterDto, semester); var result = await _context.Semesters.AddAsync(semester); await _context.SaveChangesAsync(); return(_mapper.Map <SemesterDto>(result.Entity)); }
public async Task <IEnumerable <Semester> > PutEditSemester(int id, SemesterDto semesterDto) { _logger.Debug($"{id} ID-vel rendelkező szemeszter keresése"); var semesterToEdit = await _evoNaploContext.Semesters.FindAsync(id); _logger.Debug($"{id} ID-vel rendelkező szemeszter módosítása indul {semesterDto} adatokra"); semesterToEdit.StartDate = semesterDto.StartDate; semesterToEdit.EndDate = semesterDto.EndDate; semesterToEdit.DemoDate = semesterDto.DemoDate; _evoNaploContext.SaveChanges(); _logger.Debug($"{id} ID-vel rendelkező szemeszter módosítása kész"); return(_evoNaploContext.Semesters.ToList()); }
public SemesterDto Remove(SemesterDto semesterDto) { using (var db = new AbetContext()) { var result = db.Semesters.Remove(new Semester { Id = semesterDto.Id, Name = semesterDto.Name }); db.SaveChanges(); return(new SemesterDto { Id = result.Id, Name = result.Name }); } }
public async Task <bool> DeleteSemesterAsync(SemesterDto semesterDto) { OnDelete(semesterDto); var entity = _context.Semesters .Where(x => x.Id == semesterDto.Id) .FirstOrDefault(); if (entity != null) { _context.Semesters.Remove(entity); OnBeforeDelete(entity); try { await _context.SaveChangesAsync(); } catch (DbUpdateException ex) { // _context.Entry(entity).State = EntityState.Detached; var sqlException = ex.GetBaseException() as SqlException; if (sqlException != null) { var errorMessage = "deleting error"; var number = sqlException.Number; if (number == 547) { string table = GetErrorTable(sqlException) ?? "descendant"; errorMessage = $"Must delete {table} records before deleting Semester"; } throw new Exception(errorMessage, ex); } } finally { // _context.Entry(entity).State = EntityState.Detached; } OnAfterDelete(entity); } else { return(false); } return(true); }
/// <summary> /// inside this method we call the rest api and retrieve a data /// </summary> /// <returns></returns> protected async override Task OnInitializedAsync() { int.TryParse(Id, out int planId); if (planId != 0) { Plan = await PlanService.GetPlan(int.Parse(Id)); AutumnSemester = Plan.AutumnSemester; SpringSemester = Plan.SpringSemester; Semesters = new List <SemesterDto> { AutumnSemester, SpringSemester }; SemesterId = Semester.SemesterId.ToString(); ModuleId = Module.ModuleId.ToString(); Lmr = new LecturerModuleRunDto(); SelectedPlanId = Plan.Id; ListLmr = (await LecturerModuleRunService.GetLecturerModuleRuns()).ToList(); foreach (var sem in Semesters) { foreach (var mr in sem.ModuleRuns) { ModuleRuns.Add(mr); } } await ShowLastYearPlan(); } else { Plan = new PlanDto { }; Semester = new SemesterDto { }; Module = new ModuleDto { }; ListLmr = new List <LecturerModuleRunDto> { }; } Plans = (await PlanService.GetPlans()).ToList(); ModuleRuns = (await ModuleRunService.GetModuleRuns()).ToList(); Modules = (await ModuleService.GetModules()).ToList(); Lecturers = (await LecturerService.GetLecturers()).ToList(); LecturerGroups = (await LecturerGroupService.GetLecturerGroups()).ToList(); }
public async Task <ActionResult <SemesterDto> > GetSemester(int id) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var semester = await semesterService.GetSemesterDtoAsync(id, SemesterDto.IncludeNavigations()); if (semester == null) { return(NotFound()); } return(semester); }
public async Task <ActionResult <SemesterDto> > CreateSemester(SemesterDto semester) { try { if (semester == null) { return(BadRequest()); } return(await _semesterService.CreateSemester(semester)); } catch (Exception) { return(StatusCode(StatusCodes.Status500InternalServerError, "Error retrieving data from the database")); } }
public async Task <SemesterDto> UpdateSemester(SemesterDto semesterDto) { var result = await _context.Semesters.FindAsync(semesterDto.SemesterId); if (result != null) { result.Code = semesterDto.Code; result.Date = semesterDto.Date; await _context.SaveChangesAsync(); return(_mapper.Map <SemesterDto>(result)); } return(null); }
public IActionResult UpdateByID(int id, [FromBody] SemesterDto Semester) { try { if (semesterService.Update(id, Semester)) { return(Ok("Successfully Updated")); } else { return(BadRequest("Failed to Update")); } } catch (Exception e) { return(BadRequest(e.Message)); } }
public IActionResult Add([FromBody] SemesterDto Semester) { try { if (semesterService.Add(Semester)) { return(Ok("Successfully Added")); } else { return(BadRequest("Failed to Add")); } } catch (Exception e) { return(BadRequest(e.Message)); } }
public async Task <ActionResult <SemesterDto> > UpdateSemester(SemesterDto semester) { try { var semesterForUpdate = await _semesterService.GetSemester(semester.SemesterId); if (semesterForUpdate == null) { return(NotFound($"Semester with Id={semester.SemesterId} was not found!")); } return(await _semesterService.UpdateSemester(semesterForUpdate)); } catch (Exception ex) { _logger.LogError(SR.ErrorRetrievingDataFromDataBase, ex); return(StatusCode(StatusCodes.Status500InternalServerError, SR.ErrorUpdatingDatabase)); } }
public async Task <ActionResult <IEnumerable <SemesterDto> > > GetSemesters(string searchText = null /*, int pageNumber=1, int pageSize=7*/) { // var semesters = _context.Semesters.Select(SemesterDto.AsSemesterDto); List <Expression <Func <SemesterDto, bool> > > filters = null; if (String.IsNullOrEmpty(searchText) ) { // return null; } else { filters = new List <Expression <Func <SemesterDto, bool> > >(); if (!String.IsNullOrEmpty(searchText)) { if (searchText.CompareTo("*") != 0 && searchText.CompareTo("%") != 0) { filters.Add(x => x.Id.ToString().Contains(searchText)); } } } //sort //return semesters.OrderBy(o => o.Id).Skip(((pageNumber - 1) * pageSize)).Take(pageSize); // OnSelectQuery(ref semesters); // return await semesters.ToListAsync(); if (filters == null) { return(await semesterService.GetSemesterDtoesAsync(SemesterDto.IncludeNavigations())); } else { return(await semesterService.GetSemesterDtoesAsync(SemesterDto.IncludeNavigations(), filters.ToArray())); } }
public async Task <bool> UpdateSemesterAsync(SemesterDto semesterDto, string username /*, String[] includeNavigations, params Expression<Func<Semester, bool>>[] filters*/) { OnUpdate(semesterDto, username); // Get Semester var entity = EntityQuery(_context, SemesterDto.IncludeNavigations()) .FirstOrDefault(x => x.Id == semesterDto.Id); if (entity != null) { entity = SemesterDto.ToSemesterFunc(entity, semesterDto); ToEntity(ref entity, semesterDto); //entity.UpdateUser = entity.LastActivityUser = username; //entity.UpdateDateTime = entity.LastActivityDateTime = DateTime.UtcNow; entity.EditTracker(username); OnBeforeUpdate(entity, username); try { await _context.SaveChangesAsync(); } catch (Exception ex) { // _context.Entry(entity).State = EntityState.Detached; throw new Exception("Update error", ex); } finally { // _context.Entry(entity).State = EntityState.Detached; } OnAfterUpdate(entity, username); } else { return(false); } return(true); }
public async Task <IActionResult> PutSemester(int id, SemesterDto semester) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != semester.Id) { return(BadRequest()); } try { var updated = await semesterService.UpdateSemesterAsync(semester, User.Identity.Name); if (updated) { this.RemoveCache(CacheKeys.Semester); } else { return(BadRequest("Update failed!.")); } } catch (DbUpdateConcurrencyException) { if (!SemesterExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); // return Ok(semester); }
public async Task <SemesterDto> AddOrUpdate(SemesterDto semesterDto) { var newSemester = new Semester { Id = semesterDto.Id, Name = semesterDto.Name, LastModified = DateTime.Now }; using (var db = new AbetContext()) { try { db.Semesters.AddOrUpdate(newSemester); await db.SaveChangesAsync(); } catch (Exception e) { } } return(new SemesterDto { Id = newSemester.Id, Name = newSemester.Name }); }
// -DtoQuery public async Task <SemesterDto> CreateSemesterAsync(SemesterDto semesterDto, string username) { if (_context.Semesters.Any(a => a.Name == semesterDto.Name) == true) { throw new Exception("Record exist and caused a conflict!"); } OnCreate(semesterDto, username); var entity = SemesterDto.AsSemesterFunc(semesterDto); ToEntity(ref entity, semesterDto); //entity.InsertUser = entity.LastActivityUser = username; //entity.InsertDateTime = entity.LastActivityDateTime = DateTime.UtcNow; entity.AddTracker(username); _context.Semesters.Add(entity); OnBeforeCreate(entity, username); try { await _context.SaveChangesAsync(); } catch (Exception ex) { // _context.Entry(entity).State = EntityState.Detached; throw new Exception("Add error", ex); } finally { // _context.Entry(entity).State = EntityState.Detached; } OnAfterCreate(entity, username); // semesterDto = SemesterDto.AsSemesterDtoFunc(entity); semesterDto = await GetSemesterDtoAsync(entity.Id, SemesterDto.IncludeNavigations()); return(semesterDto); }
// public async Task<ActionResult<MessageDto>> CreateCourse(CreateCourseDto createCourseDto) // public async Task<ActionResult<Semester>> CreateSemester(Semester createSemesterDto) public async Task <ActionResult <Semester> > CreateSemester(SemesterDto createSemesterDto) { var username = User.GetUsername(); var semester = new Semester { Year = createSemesterDto.Year, Term = createSemesterDto.Term // Year = 2021, // Term = "Spring" }; // this.unitOfWork.MessageRepository.AddMessage(message); this.unitOfWork.CoursesRepository.AddSemester(semester); if (await this.unitOfWork.Complete()) { return(Ok(this.mapper.Map <Semester>(semester))); } return(BadRequest("Failed to create semester")); }
public async Task <IHttpActionResult> AddOrUpdate([FromBody] SemesterDto semester) { return(Ok(await new SemesterEC().AddOrUpdate(semester))); }
partial void ToEntity(ref Semester entity, SemesterDto semesterDto);
public async Task <int> PutEditSemester(int id, SemesterDto semesterDto) { await _semesterService.PutEditSemester(id, semesterDto); return(StatusCodes.Status200OK); }
public async Task <int> /*IEnumerable<Semester>*/ PostAddSemester(SemesterDto semesterDto) { await _semesterService.PostAddSemester(semesterDto); return(StatusCodes.Status200OK); }
/// <summary> /// methods for semester /// </summary> /// <param name="semester"></param> /// <returns></returns> public async Task <SemesterDto> CreateSemester(SemesterDto semester) { return(await http.PostJsonAsync <SemesterDto>("api/semester", semester)); }
public async Task UpdateSemester(SemesterDto semester) { await http.PutJsonAsync("api/semester", semester); }