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