public ActionResult <SchoolDto> Create(SchoolDto targetValue)
{
if (string.IsNullOrWhiteSpace(targetValue.Name))
{
return(BadRequest());
}
// TODO: there are other rules for validation to consider
// e.g. we have a limit to the school name length as well as we should ensure that zip code is in the right format
var result = dataContext.Set <School>().Add(new School
{
Name = targetValue.Name,
Active = targetValue.Active,
SchoolPopulation = targetValue.SchoolPopulation,
Address = targetValue.Address == null
? null
: new Address
{
AddressLine1 = targetValue.Address.AddressLine1,
AddressLine2 = targetValue.Address.AddressLine2,
City = targetValue.Address.City,
State = targetValue.Address.State,
Zip = targetValue.Address.Zip
}
});
dataContext.SaveChanges();
targetValue.Id = result.Entity.Id;
return(Created($"/api/schools/{targetValue.Id}", targetValue));
}
public ActionResult Post([FromBody] SchoolDto dto)
{
if (string.IsNullOrEmpty(dto.RequesterEmail) || Regex.IsMatch(dto.RequesterEmail, Regexes.Email))
{
Problem("The requesterEmail is invalid");
}
if (string.IsNullOrEmpty(dto.Url) || Regex.IsMatch(dto.Url, Regexes.Url))
{
Problem("The url is invalid");
}
var school = new School
{
Name = dto.Name,
Url = dto.Url,
KeeperEmail = dto.RequesterEmail
};
school.GenerateId();
_repository.Create(school);
return(Ok("Created!"));//TODO: Saturday
}
public HttpResponseMessage Upload()
{
HttpPostedFile file = HttpContext.Current.Request.Files["school"];
ErrMsg msg = new ErrMsg();
IImport import = ExcelFactory.Instance().GetExcelImporter(new eh.impls.configurations.ExcelConfiguration(1, 0, 0), msg);
IList <School> list = SchoolDto.ToList(import.Import <SchoolDto>(file.InputStream));
if (msg.Count != 0)
{
return(ToJson(msg.GetErrors(), status_code: 0, msg: "fail"));
}
else
{
try
{
Service.Add(list);
return(ToJson("success"));
}
catch (SqlException ex)
{
msg.AddErrMsg(ex.Message);
return(ToJson(msg.GetErrors(), status_code: 0, msg: "fail"));
}
}
}
public HttpResponseMessage Post(SchoolDto value)
{
var newSchool = new School
{
Location = value.Location,
Name = value.Name
};
HttpResponseMessage response;
try
{
apiControllerHelper.Post <School>(newSchool);
var createdSchoolDto = new SchoolDto()
{
Id = newSchool.Id,
Name = newSchool.Name,
Location = newSchool.Location
};
response = Request.CreateResponse <SchoolDto>(HttpStatusCode.Created, createdSchoolDto);
var resourceLink = Url.Link("DefaultApi", new { id = createdSchoolDto.Id });
response.Headers.Location = new Uri(resourceLink);
}
catch (Exception ex)
{
response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);
}
return(response);
}
public async Task <IActionResult> UpdateSchool([FromQuery] Guid id, [FromBody] SchoolDto schoolDto)
{
try
{
if (schoolDto == null)
{
_loggerManager.LogError("SchoolDto object sent from client is null.");
return(BadRequest("SchoolDto object is null"));
}
if (!ModelState.IsValid)
{
_loggerManager.LogError("Invalid SchoolDto object sent from client.");
return(BadRequest("Invalid SchoolDto model object"));
}
var dbSchool = await _repositoryWrapper.School.GetSchoolById(id);
if (dbSchool.IsEmptyObject())
{
_loggerManager.LogError($"School with id: {id}, hasn't been found in db.");
return(NotFound());
}
var school = _mapper.Map <School>(schoolDto);
await _repositoryWrapper.School.UpdateSchool(dbSchool, school);
return(NoContent());
}
catch (Exception ex)
{
_loggerManager.LogError($"Something went wrong inside UpdateSchool action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IActionResult> CreateSchool([FromBody] SchoolDto schoolDto)
{
try
{
if (schoolDto == null)
{
_loggerManager.LogError("SchoolDto object sent from client is null.");
return(BadRequest("SchoolDto object is null"));
}
if (!ModelState.IsValid)
{
_loggerManager.LogError("Invalid SchoolDto object sent from client.");
return(BadRequest("Invalid SchoolDto model object"));
}
var school = _mapper.Map <School>(schoolDto);
await _repositoryWrapper.School.CreateSchool(school);
if (school.IsEmptyObject())
{
_loggerManager.LogError($"Save operation failed inside CreateSchool action");
return(StatusCode(500, "Internal server error while saving School "));
}
var dbSchool = await _repositoryWrapper.School.GetSchoolById(school.Id);
return(Ok(dbSchool));
}
catch (Exception ex)
{
_loggerManager.LogError($"Something went wrong inside CreateSchool action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public ActionResult <SchoolDto> Update(int id, SchoolDto targetValue)
{
var username = User.Identity.Name;
var isAdmin = User.IsInRole(Roles.Admin);
var data = dataContext.Set <School>()
.Where(x => isAdmin || x.Staff.Any(y => y.Staff.Users.Any(z => z.UserName == username)))
.FirstOrDefault(x => x.Id == id);
if (data == null)
{
return(NotFound());
}
// notice the duplication here and in create
// maybe we can reduce that duplication somehow?
data.Name = targetValue.Name;
data.Active = targetValue.Active;
data.SchoolPopulation = targetValue.SchoolPopulation;
data.Address = targetValue.Address == null
? null
: new Address
{
AddressLine1 = targetValue.Address.AddressLine1,
AddressLine2 = targetValue.Address.AddressLine2,
City = targetValue.Address.City,
State = targetValue.Address.State,
Zip = targetValue.Address.Zip
};
dataContext.SaveChanges();
return(Ok(targetValue));
}
public async Task <ActionResult <bool> > Update(Guid schoolid, SchoolDto schoolDto)
{
try
{
var schoolx = await _schoolRepo.GetSchoolWithID(schoolid);
if (schoolx == null)
{
return(BadRequest($"could not find school with id: {schoolid}"));
}
schoolx.schoolid = schoolDto.schoolid ?? schoolx.schoolid;
schoolx.name = schoolDto.name ?? schoolx.name;
schoolx.address = schoolDto.address ?? schoolx.address;
schoolx.phonenumber = schoolDto.phonenumber ?? schoolx.phonenumber;
schoolx.grade = schoolDto.grade ?? schoolx.grade;
var res = await _schoolRepo.SaveAll();
var schoolxToReturn = _mapper.Map <SchoolDto>(schoolx);
return(Ok(schoolxToReturn));
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, ex.InnerException.Message));
}
}
public async Task LoadAsync(UserEditDto userEditDto)
{
_userEditDtoJson = JsonConvert.SerializeObject(userEditDto);
_userEditDto = userEditDto;
_connectedUser = userEditDto.ConnectedUser;
_httpClientService.SetAuthorizationHeaderToken(_httpClientService.HttpClient, _connectedUser.Token);
if (_userEditDto.IsNew == null)
{
isNewSchool = true;
isNewTeacher = true;
}
else
{
switch (_userEditDto.Type)
{
case Shared.Helpers.TypeEnum.School:
isNewSchool = false;
_school = await _httpClientService.GetTAsync <School>($"school/getbyIdInclude/{_userEditDto.Entity.Id}");
var mediaSchool = _school.Medias.OrderByDescending(x => x.UploadDate).FirstOrDefault();
_schoolImagePath = await GetFilePath(_httpClientService, "school", _school, mediaSchool);
_schoolProfileImage = _schoolImagePath != null ? new BitmapImage(new Uri(_schoolImagePath)) : null;
break;
case Shared.Helpers.TypeEnum.Teacher:
isNewTeacher = false;
_teacher = await _httpClientService.GetTAsync <Teacher>($"teacher/getbyIdInclude/{_userEditDto.Entity.Id}");
SelectedSchool = new SchoolDto(_teacher.School);
var media = _teacher.Medias.OrderByDescending(x => x.UploadDate).FirstOrDefault();
_teacherImagePath = await GetFilePath(_httpClientService, "teacher", _teacher, media);
_teacherProfileImage = _teacherImagePath != null ? new BitmapImage(new Uri(_teacherImagePath)) : null;
break;
default:
isNewTeacher = true;
isNewSchool = true;
break;
}
RaisePropertyChanged(nameof(School));
RaisePropertyChanged(nameof(Teacher));
RaisePropertyChanged(nameof(SelectedSchool));
RaisePropertyChanged(nameof(ProfileImageSource));
RaisePropertyChanged(nameof(TeacherProfileImage));
}
var getSchools = await _httpClientService.GetListTAsync <School>("school/getall");
foreach (var school in getSchools)
{
_schools.Add(new SchoolDto(school));
}
_teachersList = getSchools.Select(s => s.Principle).Distinct().ToList();
_selectTeachers = new ObservableCollection <string>(_teachersList);
RaisePropertyChanged(nameof(Schools));
RaisePropertyChanged(nameof(SelectTeachers));
}
private bool validate(SchoolDto request)
{
if (request == null)
return setValidation("No request was found!");
if (request.Name.IsNullOrEmpty())
return setValidation("You must enter a department name!");
return true;
}
public async Task <IActionResult> AddNewSchool(SchoolDto body)
{
var dto = mapper.Map <SchoolDto, School>(body);
_unitOfWork.SchoolRepository.AddRecord(dto);
await _unitOfWork.SaveAsync();
return(Ok());
}
public async Task <IActionResult> PutSchool(string id, SchoolDto schoolDto)
{
var school = _mapper.Map <School>(schoolDto);
school.Id = id;
var result = await _schoolService.UpdateSchool(school);
var response = new ApiResponse <bool>(result);
return(Ok(response));
}
public ActionResult Edit(SchoolDto school)
{
if (ModelState.IsValid)
{
var sc = db.Schools.Find(school.Id);
sc.Name = school.Name;
db.Entry(sc).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public async Task <ActionResult <SchoolDto> > GetUserSchool()
{
var user = await _userManager.FindByUserByClaimsPrincipleWithSchoolAsync(HttpContext.User);
var data = _mapper.Map <School, SchoolDto>(user.School);
var keko = new SchoolDto
{
SchoolNameId = user.School.SchoolNameId,
DinnerTimeId = user.School.DinnerTimeId
};
return(Ok(keko));
}
public SchoolDto GetSchool(int id)
{
School school = lernsiegService.GetSchool(id);
SchoolDto schoolDto = new SchoolDto
{
Id = school.Id,
Name = school.Name,
Country = school.Country,
SchoolNumber = school.SchoolNumber,
Address = school.Address,
};
return(schoolDto);
}
public static async Task Seed(ISchoolAppDbContext context)
{
var entity = new SchoolDto()
{
id = Guid.Parse("eae2acee-5b9c-4f4b-a477-8668fee43fea"),
name = "Seeded School, For Testing"
};
if (context.Schools.Any(x => x.id == entity.id))
{
return;
}
context.Schools.Add(entity);
await context.SaveChangesAsync();
}
public IHttpActionResult Add(SchoolDto school)
{
try
{
var insertedRow = (IDictionary <string, object>)_sqlDA.SaveData <dynamic>("dbo.spSchools_Add",
new { school.City, school.CreationDate, school.Description, school.EmailAddress, school.Name, school.PostalCode, school.Street, school.TelephoneNumber, school.WebAddress });
insertedRow.TryGetValue("Id", out object insertedId);
return(Created <string>("", insertedId?.ToString()));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public IHttpActionResult GetSchool(int id)
{
School t = db.Schools.Find(id);
SchoolDto school = new SchoolDto()
{
Id = t.Id, Address1 = t.Address1, Address2 = t.Address2, Contact = t.ContactNumber, Email = t.Email, Name = t.Name
};
if (school == null)
{
return(NotFound());
}
return(Ok(school));
}
public ActionResult Create(SchoolDto school)
{
if (ModelState.IsValid)
{
var schoolEntity = new School //object initializer
{
Name = school.Name
};
db.Schools.Add(schoolEntity);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public ActionResult Edit(int id)
{
School s = db.Schools.Find(id);
if (s == null)
{
return(HttpNotFound());
}
var school = new SchoolDto
{
Name = s.Name
};
return(View(school));
}
public async Task <IActionResult> UpdateSchool(string Id, SchoolDto school)
{
//Imp
var querySchoolObj = _unitOfWork.SchoolRepository.GetSingleRecord(Id);
querySchoolObj.Result.SchCode = school.SchCode;
querySchoolObj.Result.SchName = school.SchName;
querySchoolObj.Result.SchDeanName = school.SchDeanName;
querySchoolObj.Result.SchPhone = school.SchPhone;
await _unitOfWork.SaveAsync();
return(Ok(querySchoolObj.Result));
}
public async Task <IActionResult> PostSchool(SchoolDto schoolDto)
{
// Console.Write("al api");
//var school = new School
//{
// Name = schoolDto.Name,
// Description = schoolDto.Description,
// Logo = schoolDto.Logo,
// Status = schoolDto.Status
//};
var school = _mapper.Map <School>(schoolDto);
await _schoolService.InsertSchool(school);
var response = new ApiResponse <bool>(true);
return(Ok(response));
}
public void CreateSchool()
{
// Arrange
var schoolDto = new SchoolDto
{
Name = "New School 1"
};
var school = _mapper.Map <School>(schoolDto);
Mock.Get(_repositoryWrapper.School).Setup(x => x.CreateSchool(school));
Mock.Get(_repositoryWrapper.School).Setup(x => x.GetSchoolById(school.Id)).ReturnsAsync(school);
var controller = new SchoolController(_loggerManager, _mapper, _repositoryWrapper);
// Act
var actionResult = controller.CreateSchool(schoolDto).Result;
// Assert
var okObjectResult = actionResult as OkObjectResult;
Assert.IsNotNull(okObjectResult);
}
public void UpdateSchool()
{
// Arrange
var schoolDto = new SchoolDto
{
Name = "Update School 1"
};
var school = _mapper.Map <School>(schoolDto);
school.Id = Guid.NewGuid();
Mock.Get(_repositoryWrapper.School).Setup(x => x.UpdateSchool(school, school));
Mock.Get(_repositoryWrapper.School).Setup(x => x.GetSchoolById(school.Id)).ReturnsAsync(school);
var controller = new SchoolController(_loggerManager, _mapper, _repositoryWrapper);
// Act
var actionResult = controller.UpdateSchool(school.Id, schoolDto).Result;
// Assert
var noContentResult = actionResult as NoContentResult;
Assert.IsNotNull(noContentResult);
}
public async Task <IActionResult> PutSchools(int id, SchoolDto schoolDto)
{
if (schoolDto.Id == 0)
{
schoolDto.Id = id;
}
if (id != schoolDto.Id)
{
return(BadRequest());
}
var school = await _context.Schools.FirstOrDefaultAsync(_ => _.Id == schoolDto.Id);
if (school == null)
{
return(NotFound());
}
if (schoolDto.Name != null)
{
school.Name = schoolDto.Name;
}
if (schoolDto.Display != null)
{
school.Display = schoolDto.Display.Value;
}
school.DateModified = DateTime.Now;
_context.Entry(school).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(RedirectToAction("GetSchools", new { id = schoolDto.Id }));
}
public async Task <IActionResult> PostSchools(SchoolDto schoolDto)
{
if (schoolDto.Id == 0)
{
if (schoolDto.Name == null)
{
return(BadRequest());
}
if (schoolDto.Display == null)
{
schoolDto.Display = true;
}
var school = _mapper.Map <School>(schoolDto);
_context.Schools.Add(school);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetSchools", new { id = school.Id }, _mapper.Map <SchoolDto>(school)));
}
else
{
return(await PutSchools(schoolDto.Id, schoolDto));
}
}
public IActionResult Put_Schools(int key, [FromBody] SchoolDto update)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (key != update.Id)
{
return(BadRequest());
}
var school = _db.Schools.AsTracking()
.Include(x => x.Students).SingleOrDefault(x => x.Id == key);
//_db.Schools.AsTracking()
//.Include(x => x.Registry).SingleOrDefault(x => x.Id == key);
_db.Schools.Persist().InsertOrUpdate(update);
try
{
_db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!_SchoolsExists(key))
{
return(NotFound());
}
else
{
throw;
}
}
return(Updated(school));
}
public async Task <IActionResult> GetSchools()
{
var schools = await _studentService.GetSchools();
return(Ok(SchoolDto.Map(schools)));
}
public SchoolDto Add(SchoolDto subject)
{
return(schoolStorage.Add(subject));
}
public void Update(SchoolDto subject)
{
schoolStorage.Update(subject);
}
public Task <SchoolDto> Update(SchoolDto entity)
{
throw new NotImplementedException();
}
