//Update ImageFileType (async)
public async Task <ImageFileTypeDTO> UpdateImageFileTypeAsync(ImageFileTypeDTO modelDTO)
{
try
{
using (var unitOfWork = unitOfWorkFactory.Create())
{
ImageFileTypeModel model = _Mapper_ToModel.Map <ImageFileTypeDTO, ImageFileTypeModel>(modelDTO);
bool result = unitOfWork.ImageFileTypeRepository.Update(model);
ImageFileTypeDTO modelRTN = null;
if (result)
{
await unitOfWork.SaveChangesAsync();
modelRTN = _Mapper_ToDTO.Map <ImageFileTypeModel, ImageFileTypeDTO>(model);
}
return(modelRTN);
}
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
//Add Event (async)
public async Task <int> AddEventAsync(EventDTO modelDTO)
{
try
{
using (var unitOfWork = unitOfWorkFactory.Create())
{
if (!string.IsNullOrEmpty(modelDTO._ImageFileUrl))
{
var tempImageTypeModel = unitOfWork.ImageFileTypeRepository.GetSingleOrDefaultImageFileType(x => x.Type.Contains("EventImage"));
ImageFileTypeDTO imageFileTypeDTO = _Mapper_ToDTO.Map <ImageFileTypeModel, ImageFileTypeDTO>(tempImageTypeModel);
modelDTO.ImageFileUrl = new ImageFileUrlDTO()
{
Url = modelDTO._ImageFileUrl,
CreateDate = DateTime.Now,
ImageFileTypeId = imageFileTypeDTO.ImageFileTypeId
};
}
else
{
modelDTO.ImageFileUrl = null;
}
//if (modelDTO._ImageFileUrls.Count() > 0)
//{
// var tempImageType = unitOfWork.ImageFileTypeRepository.GetSingleOrDefaultImageFileType(x => x.Type.Contains("EventImage"));
// foreach (var img in modelDTO._ImageFileUrls)
// {
// modelDTO.ImageFileUrls.Add(new ImageFileUrlDTO()
// {
// Url = img,
// CreateDate = DateTime.Now,
// ImageFileType = new ImageFileTypeDTO { ImageFileTypeId = tempImageType.ImageFileTypeId, Type = tempImageType.Type }
// });
// }
//}
EventModel model = _Mapper_ToModel.Map <EventDTO, EventModel>(modelDTO);
unitOfWork.EventRepository.Add(model);
//unitOfWork.Repository.Add<EventModel>(model);
await unitOfWork.SaveChangesAsync();
return(model.EventId);
}
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
public async Task <IHttpActionResult> GetImageFileType(int id)
{
ImageFileTypeDTO dto = await ImageFileTypeService.SearchSingleImageFileTypeByIdAsync(id);
if (dto != null)
{
return(Ok(dto));
}
else
{
return(NotFound());
}
}
//Update Student (async)
public async Task <StudentDTO> UpdateStudentAsync(StudentDTO modelDTO)
{
try
{
using (var unitOfWork = unitOfWorkFactory.Create())
{
//var tempStandard = unitOfWork.StandardRepository.GetSingleOrDefaultStandard(x => x.StandardId == modelDTO.Standard_StandardId);
//modelDTO.Standard = _Mapper_ToDTO.Map<StandardModel, StandardDTO>(tempStandard);
if (!string.IsNullOrEmpty(modelDTO._ImageFileUrl))
{
var tempImageTypeModel = unitOfWork.ImageFileTypeRepository.GetSingleOrDefaultImageFileType(x => x.Type.Contains("StudentImage"));
ImageFileTypeDTO imageFileTypeDTO = _Mapper_ToDTO.Map <ImageFileTypeModel, ImageFileTypeDTO>(tempImageTypeModel);
modelDTO.ImageFileUrl = new ImageFileUrlDTO()
{
Url = modelDTO._ImageFileUrl,
CreateDate = DateTime.Now,
ImageFileTypeId = imageFileTypeDTO.ImageFileTypeId
};
}
else
{
modelDTO.ImageFileUrl = null;
}
StudentModel model = _Mapper_ToModel.Map <StudentDTO, StudentModel>(modelDTO);
bool result = unitOfWork.StudentRepository.Update(model);
StudentDTO modelRTN = null;
if (result)
{
await unitOfWork.SaveChangesAsync();
modelRTN = _Mapper_ToDTO.Map <StudentModel, StudentDTO>(model);
}
return(modelRTN);
}
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
public async Task <IHttpActionResult> UpdateImageFileType([FromBody] ImageFileTypeDTO ImageFileTypeModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var updatedImageFileType = await ImageFileTypeService.UpdateImageFileTypeAsync(ImageFileTypeModel);
if (updatedImageFileType != null)
{
return(Ok(updatedImageFileType));
}
else
{
return(NotFound());
}
}
//Update Attendance (async)
public async Task <AttendanceDTO> UpdateAttendanceAsync(AttendanceDTO modelDTO)
{
try
{
using (var unitOfWork = unitOfWorkFactory.Create())
{
if (!string.IsNullOrEmpty(modelDTO._ImageFileUrl))
{
var tempImageTypeModel = unitOfWork.ImageFileTypeRepository.GetSingleOrDefaultImageFileType(x => x.Type.Contains("AttendanceImage"));
ImageFileTypeDTO imageFileTypeDTO = _Mapper_ToDTO.Map <ImageFileTypeModel, ImageFileTypeDTO>(tempImageTypeModel);
modelDTO.ImageFileUrl = new ImageFileUrlDTO()
{
Url = modelDTO._ImageFileUrl,
CreateDate = DateTime.Now,
ImageFileTypeId = imageFileTypeDTO.ImageFileTypeId
};
}
else
{
modelDTO.ImageFileUrl = null;
}
AttendanceModel model = _Mapper_ToModel.Map <AttendanceDTO, AttendanceModel>(modelDTO);
bool result = unitOfWork.AttendanceRepository.Update(model);
AttendanceDTO modelRTN = null;
if (result)
{
await unitOfWork.SaveChangesAsync();
modelRTN = _Mapper_ToDTO.Map <AttendanceModel, AttendanceDTO>(model);
}
return(modelRTN);
}
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
public async Task <IHttpActionResult> AddImageFileType([FromBody] ImageFileTypeDTO ImageFileTypeModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newImageFileTypeId = await ImageFileTypeService.AddImageFileTypeAsync(ImageFileTypeModel);
if (newImageFileTypeId != 0)
{
return(Ok(newImageFileTypeId));
}
else
{
return(NotFound());
}
}
//Add ImageFileType (async)
public async Task <int> AddImageFileTypeAsync(ImageFileTypeDTO modelDTO)
{
try
{
using (var unitOfWork = unitOfWorkFactory.Create())
{
ImageFileTypeModel model = _Mapper_ToModel.Map <ImageFileTypeDTO, ImageFileTypeModel>(modelDTO);
unitOfWork.ImageFileTypeRepository.Add(model);
//unitOfWork.Repository.Add<ImageFileTypeModel>(model);
await unitOfWork.SaveChangesAsync();
return(model.ImageFileTypeId);
}
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
//Add Teacher (async)
public async Task <int> AddTeacherAsync(TeacherDTO modelDTO)
{
try
{
using (var unitOfWork = unitOfWorkFactory.Create())
{
if (!string.IsNullOrEmpty(modelDTO._ImageFileUrl))
{
var tempImageTypeModel = unitOfWork.ImageFileTypeRepository.GetSingleOrDefaultImageFileType(x => x.Type.Contains("TeacherImage"));
ImageFileTypeDTO imageFileTypeDTO = _Mapper_ToDTO.Map <ImageFileTypeModel, ImageFileTypeDTO>(tempImageTypeModel);
modelDTO.ImageFileUrl = new ImageFileUrlDTO()
{
Url = modelDTO._ImageFileUrl,
CreateDate = DateTime.Now,
ImageFileTypeId = imageFileTypeDTO.ImageFileTypeId
};
}
else
{
modelDTO.ImageFileUrl = null;
}
TeacherModel model = _Mapper_ToModel.Map <TeacherDTO, TeacherModel>(modelDTO);
//unitOfWork.TeacherRepository.Add(model);
unitOfWork.Repository.Add <TeacherModel>(model);
await unitOfWork.SaveChangesAsync();
return(model.TeacherId);
}
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
