public JsonResult SubjectEdit(int SubjectId, SubjectModel SubjectModel)
{
try
{
if (SubjectId == 0)
{
Core3Base.Infra.Data.Entity.Subjects Subject = new Core3Base.Infra.Data.Entity.Subjects
{
SubjectName = SubjectModel.Subject.SubjectName,
IsActive = SubjectModel.Subject.IsActive,
LessonId = SubjectModel.Subject.LessonId
};
return(Json(_SubjectService.Add(Subject).HttpGetResponse()));
}
else
{
var Subject = _SubjectService.GetSubjectById(SubjectId).Result;
Subject.IsActive = SubjectModel.Subject.IsActive;
Subject.SubjectName = SubjectModel.Subject.SubjectName;
Subject.LessonId = SubjectModel.Subject.LessonId;
Subject.DateModified = DateTime.Now;
return(Json(_SubjectService.Update(Subject).HttpGetResponse()));
}
}
catch (Exception e)
{
return(Json(e.Message));
}
}
public ActionResult Subjects_Create([DataSourceRequest] DataSourceRequest request, Subject subject)
{
if (ModelState.IsValid)
{
_subjectService.Add(subject);
}
return(Json(new[] { subject }.ToDataSourceResult(request, ModelState)));
}
public async Task <IActionResult> CreatePost(Subject subject, List <Class> classes)
{
subject.classes = classes;
if (ModelState.IsValid)
{
await subjectService.Add(subject);
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(SubjectInputModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await subjectService.Add(model);
return(RedirectToAction(nameof(GetAll)));
}
public IActionResult Post(string subjectName)
{
if (_service.GetByName(subjectName) != null)
{
return(BadRequest(new { Message = $"Subject with name '{subjectName}' already exists." }));
}
_service.Add(new Subject {
Name = subjectName
});
return(Ok());
}
public async Task <IActionResult> Post([FromBody] Subject subject)
{
//if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
//}
await _subjectService.Add(subject);
return(CreatedAtAction("GetSubject", new { id = subject.SubjectId }, subject));
}
public IActionResult Add([FromQuery] SubjectViewModel model)
{
var SubjectsResponse = _SubjectsService.Add(new Subjects
{
LessonId = model.LessonId
});
if (SubjectsResponse.IsSucceeded && SubjectsResponse.Result != null)
{
return(Ok(SubjectsResponse.Result));
}
return(SubjectsResponse.HttpGetResponse());
}
public async Task <IActionResult> Add(SubjectDto subjectDto)
{
try
{
await _subjectService.Add(subjectDto);
return(Ok("Konu Başarıyla Kaydedildi"));
}
catch
{
return(BadRequest("Konu Ekleme İşlemi Başarısız"));
}
}
public IActionResult Add(SubjectAddModel model)
{
var data = _subjectService.Add(model);
if (data > 0)
{
return(ApiResult(message: "添加成功！", httpStatusCode: (int)HttpStatusCode.OK));
}
else
{
return(ApiResult(message: "添加失败！", httpStatusCode: (int)HttpStatusCode.Forbidden));
}
}
public ActionResult AddSubject(AddSubjectViewModel model)
{
Subject subject = new Subject();
subject.Name = model.SubjectName;
if (subject.Name.IsNullOrWhiteSpace())
{
TempData["msg"] = "<script>alert('לא הוכנס נושא');</script>";
return(View());
}
if (_subjectService.GetByName(model.SubjectName) == null)
{
try
{
_subjectService.Add(subject);
foreach (var cls in _classService.All().Include(x => x.Subjects).ToList())
{
var className = cls.ClassLetter + " " + cls.ClassNumber;
if (className.Equals(Session["CurrentClass"].ToString()))
{
cls.Subjects.Add(subject);
_classService.Update(cls);
}
}
}
catch (Exception)
{
TempData["msg"] = "<script>alert('אירעה תקלה בהוספת הנושא');</script>";
return(View());
}
}
else
{
TempData["msg"] = "<script>alert('הנושא המבוקש כבר קיים');</script>";
return(View());
}
SchoolClass schoolClass = GetClass(Session["CurrentClass"].ToString());
InitializeClassView(schoolClass);
TempData["msg"] = "<script>alert('הנושא נוסף בהצלחה');</script>";
return(View("ClassView"));
}
public async virtual Task <ActionResult> CreateEdit(SubjectViewModel model)
{
var subj = _mapper.Map <Subject>(model);
if (ModelState.IsValid)
{
if (subj.Id == null)
{
_sbjService.Add(subj);
}
else
{
await _sbjService.UpdateAsync(subj);
}
return(RedirectToAction(MVC.Subject.Actions.Index()));
}
return(View());
}
public IActionResult SaveEntity(SubjectViewModel subjectViewModel)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
if (subjectViewModel.Id == 0)
{
_subjectService.Add(subjectViewModel);
}
else
{
_subjectService.Update(subjectViewModel);
}
_subjectService.SaveChanges();
return(new OkObjectResult(subjectViewModel));
}
public HttpResponseMessage Post(HttpRequestMessage request, SubjectViewModel SubjectVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
Subject newSubject = new Subject();
newSubject.UpdateSubject(SubjectVm);
var responseData = _subjectService.Add(newSubject);
_subjectService.Save();
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public async Task <IHttpActionResult> Add([FromBody] SubjectDTO subject)
{
var response = new OverviewResponse <SubjectOverview>();
try
{
Subject newsubject = _mapper.Map <SubjectDTO, Subject>(subject);
newsubject.TeacherId = subject.SelectedTeacher;
var result = _subjectService.Add(newsubject);
if (result == null)
{
response.IsSuccess = false;
response.Errors.Add("Already exists!");
return(Ok(response));
}
var overviews = GetSubjectOverview();
response.IsSuccess = !response.Errors.Any();
response.Overview = overviews;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Errors.Add(ex.Message);
response.Errors.Add("-----------------------------------");
response.Errors.Add(ex.InnerException.Message);
var overviews = GetSubjectOverview();
response.Overview = overviews;
return(Ok(response));
}
//Call overview
var hubContext = GlobalHost.ConnectionManager.GetHubContext <ClientHub>();
hubContext.Clients.All.reloadSubject(response);
return(Ok(response));
}
public RegistrationMutation(IAddressService addressService, ICourseService courseService, IStudentService studentService, ISubjectService subjectService)
{
FieldAsync <AddressType>
(
"AddAddress",
arguments: new QueryArguments
(
new QueryArgument <NonNullGraphType <AddressInputType> > {
Name = "address"
}
),
resolve: async ctx =>
{
var address = ctx.GetArgument <Address>("address");
return(await addressService.Add(address));
}
);
FieldAsync <AddressType>
(
"updateAddress",
arguments: new QueryArguments
(
new QueryArgument <NonNullGraphType <AddressInputType> > {
Name = "address"
},
new QueryArgument <NonNullGraphType <IntGraphType> > {
Name = "addressId"
}
),
resolve: async ctx =>
{
var address = ctx.GetArgument <Address>("address");
var addressId = ctx.GetArgument <int>("addressId");
var existingAddress = addressService.GetById(addressId);
if (existingAddress == null)
{
return(null);
}
address.Id = addressId;
return(await addressService.Update(addressId, address));
}
);
FieldAsync <CourseType>
(
"AddCourse",
arguments: new QueryArguments
(
new QueryArgument <NonNullGraphType <CourseInputType> > {
Name = "course"
}
),
resolve: async ctx =>
{
var course = ctx.GetArgument <Course>("course");
return(await courseService.Add(course));
}
);
FieldAsync <CourseType>
(
"updateCourse",
arguments: new QueryArguments
(
new QueryArgument <NonNullGraphType <CourseInputType> > {
Name = "course"
},
new QueryArgument <NonNullGraphType <IntGraphType> > {
Name = "courseId"
}
),
resolve: async ctx =>
{
var course = ctx.GetArgument <Course>("course");
var courseId = ctx.GetArgument <int>("courseId");
var existingCourse = await courseService.GetById(courseId);
if (existingCourse == null)
{
return(null);
}
course.Id = courseId;
return(await courseService.Update(courseId, course));
}
);
FieldAsync <StudentType>
(
"addStudent",
arguments: new QueryArguments
{
new QueryArgument <NonNullGraphType <StudentInputType> > {
Name = "student"
}
},
resolve: async ctx =>
{
var student = ctx.GetArgument <Student>("student");
return(await studentService.Add(student));
}
);
FieldAsync <StudentType>
(
"updateStudent",
arguments: new QueryArguments
(
new QueryArgument <NonNullGraphType <StudentInputType> > {
Name = "student"
},
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "studentNumber"
}
),
resolve: async ctx =>
{
var student = ctx.GetArgument <Student>("student");
var studentNumber = ctx.GetArgument <string>("studentNumber");
var existingStudent = await studentService.GetByStudentNumber(studentNumber);
if (existingStudent == null)
{
return(null);
}
student.StudentNumber = studentNumber;
return(await studentService.Update(studentNumber, student));
}
);
FieldAsync <SubjectType>
(
"addSubject",
arguments: new QueryArguments
{
new QueryArgument <NonNullGraphType <SubjectInputType> > {
Name = "subject"
}
},
resolve: async ctx =>
{
var subject = ctx.GetArgument <Subject>("subject");
return(await subjectService.Add(subject));
}
);
FieldAsync <SubjectType>
(
"updateSubject",
arguments: new QueryArguments
(
new QueryArgument <NonNullGraphType <SubjectInputType> > {
Name = "subject"
},
new QueryArgument <NonNullGraphType <IntGraphType> > {
Name = "subjectId"
}
),
resolve: async ctx =>
{
var subject = ctx.GetArgument <Subject>("subject");
var subjectId = ctx.GetArgument <int>("subjectId");
var existingSubject = subjectService.GetById(subjectId);
if (existingSubject == null)
{
return(null);
}
subject.Id = subjectId;
return(await subjectService.Update(subjectId, subject));
}
);
}
public Subject Add(Subject subject)
{
return(subjectService.Add(subject));
}
public void Post([FromBody] Subject subject)
{
_subjectService.Add(subject);
}
public bool Add(Subject entity)
{
return(_service.Add(entity));
}
public int Add([FromBody] Subject subject)
{
return(_service.Add(subject).Id);
}