public async Task <DataResult <ClassModel> > CreateClass(ClassModel model)
{
try
{
Class entity = _mapper.MapBack(model);
DataResult <Class> result = await _classRepository.Add(entity);
return(new DataResult <ClassModel>
{
Success = result.Success,
ErrorCode = result.ErrorCode,
Data = _mapper.Map(result.Data),
});
}
catch (Exception ex)
{
_logger.LogError(ex, $"Problems with creating Class");
return(new DataResult <ClassModel>
{
Success = false,
ErrorCode = ErrorCode.InternalError,
});
}
}
public async Task <IActionResult> AddClass([FromBody] ClassDTO @class)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid input"));
}
Class newClass = new Class()
{
id = @class.id,
name = @class.name,
students = @class.students
};
if (_classRepository.CheckIfExists(newClass))
{
return(Conflict("Class already exists"));
}
bool created = await _classRepository.Add(newClass);
if (created)
{
return(Created("", newClass));
}
return(Conflict());
}
public async Task <ActionResult <Class> > CreateClass(ClassDto classDto)
{
var classData = getClassData(classDto);
if (await _classRepository.ClassExists(classData.ClassName, classData.CompanyId))
{
return(BadRequest("A Class with the name '" + classData.ClassName + "' already exists for this company"));
}
int classId;
if (_classRepository.Add(classData, out classId))
{
bool updateSuccess = true;
if (classDto.IsHsaClass)
{
classDto.HsaClassDetails.ElementAt(0).ClassId = classId;
int hsaClassDetailId;
updateSuccess = _hsaClassDetailsRepository.Add(GetHsaClassDetails(classDto.HsaClassDetails), out hsaClassDetailId);
}
if (updateSuccess)
{
return(NoContent());
}
}
return(BadRequest("Failed to add class"));
}
// POST api/Class
public IHttpActionResult PostClass(Addclass item /*, HttpPostedFileBase file*/)
{
//Dictionary<string, object> dict = new Dictionary<string, object>();
// string str = files(file);
// item.Img = str;
try
{
var httpRequest = HttpContext.Current.Request;
item = repository.Add(item);
repository.Save();
//var response = Request.CreateResponse<Addclass>(HttpStatusCode.Created, item);
//string uri = Url.Link("DefaultApi", new { id = item.CId });
//response.Headers.Location = new Uri(uri);
// return Ok();
var data = repository.GetAll();
if (data == null)
{
return(NotFound());
}
return(Ok(data));
}
catch
{
return(InternalServerError());
}
}
public void Post([FromBody] Class model)
{
if (ModelState.IsValid)
{
Repository.Add(model);
Repository.Save();
}
}
public int Add(ViewClass entity)
{
entity.CreateTime = DateTime.Now;
entity.UpdateTime = DateTime.Now;
Class @class = _repository.Add(ViewClass.ToEntity(entity));
entity.Id = @class.Id;
return(entity.Id);
}
public RedirectToRouteResult DoCreate(ClassModel model)
{
classRepository.Add(new Class(model.Name, model.Credits));
return(RedirectToRoute(new
{
action = "Index",
controller = "Class"
}));
}
public IActionResult PostClass([FromBody] Class classs)
{
using (var scope = new TransactionScope())
{
_classRepository.Add(classs);
classs.AuthorName = User.FindFirstValue(ClaimTypes.NameIdentifier);
scope.Complete();
return(CreatedAtAction(nameof(GetClass), new { id = classs.ClassId }, classs));
}
}
public IActionResult Create([FromBody] Classroom classroom)
{
var getClassroom = _service.Add(classroom.Name);
if (getClassroom != null)
{
return(Ok(new { success = true, classroom = getClassroom }));
}
return(Json(new { success = false }));
}
public void AddClassToStudent(ClassRequest classRequest)
{
var cls = new Class {
Id = classRequest.ClassId, StartDateTime = DateTime.Today
};
cls.Students.Add(new Student {
Id = classRequest.StudentId
});
_classRepository.Add(cls);
}
public IActionResult AddClass([FromBody] Class entities)
{
try
{
_classRepository.Add(entities);
var Respond = Ok();
responses.StatusCode = Respond.StatusCode;
responses.Message = Constants.Success;
return(Ok(responses));
}
catch (Exception)
{
var Respond = BadRequest();
responses.StatusCode = Respond.StatusCode;
responses.Message = Constants.Failure;
return(BadRequest(responses));
}
}
public async Task Create(CreateClassDto @class)
{
var careers = _careerRepository.Filter(career => @class.Careers.Contains(career.Id));
var classInfo = new Class
{
ClassCode = @class.ClassCode,
ClassName = @class.ClassName
};
foreach (var career in careers)
{
classInfo.ClassCareers.Add(new ClassCareer {
Career = career
});
}
await _classRepository.Add(classInfo);
}
public async Task <ClassResponse> Register(CreateClassRequest request, User user)
{
if (user == null)
{
Notify("User not found");
}
if (!HasNotification())
{
var newClass = new Class(request.Name, user);
var createdClass = await _classRepository.Add(newClass);
return(new ClassResponse()
{
Id = createdClass.Id,
Name = createdClass.Name
});
}
else
{
return(null);
}
}
public void CreateClass(ClassDto ClassDto)
{
var ClassToCreate = _ClassRepository.GetBy(ClassDto.ID);
_ClassRepository.Add(ClassToCreate);
}
public UserModel Add(int classId, int userId)
{
var user = classRepository.Add(classId, userId);
return(new UserModel(user.UserId, user.UserEmail, user.UserPassword, user.UserIsAdmin));
}
