public async Task <MessageModel <string> > Add(Student student)
{
var data = new MessageModel <string>();
if (student != null)
{
student.Id = Guid.NewGuid().ToString("N");
student.IsDelete = false;
student.CreateDate = DateTime.Now;
var result = await _studentService.Add(student);
data.Success = result > 0;
if (!data.Success)
{
return(data);
}
data.Response = result.ObjToString();
}
data.Msg = "添加成功";
// TODO：添加日志到数据库
return(data);
}
public void Test_StudentIntegration_Add_SholdBeOk()
{
int expectedAmount = 4;
Student studentToSave = ObjectMother.GetNewValidStudent();
Student studentSaved = _service.Add(studentToSave);
studentSaved.Id.Should().BeGreaterThan(0);
IList <Student> students = _service.GetAll();
students.Count.Should().Be(expectedAmount);
students.Last().Id.Should().Be(studentSaved.Id);
}
public void Test_StudentService_Add_ShouldBeOk()
{
int studentExistentId = 1;
Student studentToSave = ObjectMother.GetNewValidStudent();
_mockRepository.Setup(r => r.Save(studentToSave)).Returns(ObjectMother.GetExistentValidStudent());
Student studentReturned = _service.Add(studentToSave);
studentReturned.Id.Should().Be(studentExistentId);
_mockRepository.Verify(r => r.Save(studentToSave));
_mockResultRepository.VerifyNoOtherCalls();
}
public async Task <ActionResult> Create(Student student, IFormFile image)
{
try
{
string path;
if (image == null && student.Gender == "Kız")
{
path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot\\images\\", "kizogrenci.jpg");
student.ImagePath = "kizogrenci.jpg";
}
else if (image == null && student.Gender == "Erkek")
{
path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot\\images\\", "erkekogrenci.png");
student.ImagePath = "erkekogrenci.png";
}
else
{
path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot\\images\\", image.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
await image.CopyToAsync(stream);
}
student.ImagePath = image.FileName;
}
studentService.Add(student);
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
return(View(ex.Message));
}
}
public async Task <IHttpActionResult> Add([FromBody] StudentDTO student)
{
var response = new OverviewResponse <StudentOverview>();
try
{
Student newStudent = _mapper.Map <StudentDTO, Student>(student);
var result = _studentService.Add(newStudent);
if (result == null)
{
response.IsSuccess = false;
response.Errors.Add("Already exists!");
}
var overviews = GetStudentOverview();
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 = GetStudentOverview();
response.Overview = overviews;
return(Ok(response));
}
//Call overview
var hubContext = GlobalHost.ConnectionManager.GetHubContext <ClientHub>();
hubContext.Clients.All.reloadStudent(response);
return(Ok(response));
}
public void Test2()
{
IStudentService student = Lark.Core.Lark.Wrap <IStudentService>("http://*****:*****@"/api/student/add?ID=1&Name=name&rank=23");
//--------------------------------------
student.Add2(new IStudentService.Student()
{
ID = 1, Name = "name", rank = 23
}, new IStudentService.StudentClass()
{
}, new IStudentService.Remark()
{
});
wrap = (WrapBase)student;
httpRequestHeaders = wrap.MyHttpRequestMessagea.Headers;
httpContent = wrap.MyHttpRequestMessagea.Content;
System.Console.WriteLine(wrap.GetRequestCreURL());
//Assert.Catch( delegate {} ,"",null);
}
public JsonResult StudentEdit(int StudentId, StudentModel StudentModel)
{
try
{
if (StudentId == 0)
{
Core3Base.Infra.Data.Entity.Student Student = new Core3Base.Infra.Data.Entity.Student
{
Name = StudentModel.Student.Name,
Email = StudentModel.Student.Email,
ClassId = StudentModel.Student.ClassId,
IsActive = StudentModel.Student.IsActive,
Surname = StudentModel.Student.Surname
};
return(Json(_studentService.Add(Student).HttpGetResponse()));
}
else
{
var Student = _studentService.GetStudentById(StudentId).Result;
Student.Name = StudentModel.Student.Name;
Student.Email = StudentModel.Student.Email;
Student.ClassId = StudentModel.Student.ClassId;
Student.IsActive = StudentModel.Student.IsActive;
Student.Surname = StudentModel.Student.Surname;
Student.DateModified = DateTime.Now;
return(Json(_studentService.Update(Student).HttpGetResponse()));
}
}
catch (Exception e)
{
return(Json(e.Message));
}
}
public IActionResult Create(StudentCreateViewModel studentViewModel)
{
if (ModelState.IsValid)
{
string uniqueFileName;
StudentModel student = studentViewModel.Student;
if (studentViewModel.Photo != null)
{
//指定上传的文件储存在wwwroot/images文件夹中
string uploadFolder = Path.Combine(_hostEnvironment.WebRootPath, "images");
//为上传的文件添加GUID文件名
uniqueFileName = Guid.NewGuid().ToString() + "_" + studentViewModel.Photo.FileName;
string filePath = Path.Combine(uploadFolder, uniqueFileName);
//把上传的文件从内存中拷贝到硬盘上
studentViewModel.Photo.CopyToAsync(new FileStream(filePath, FileMode.Create));
student.PhotoPath = uniqueFileName;
}
else
{
//如果用户没有上传图片，则使用默认图片。
student.PhotoPath = "default.jpg";
}
//把新创建的student提交到数据库
_studentService.Add(student);
//完成后，返回到详情页面
return(RedirectToAction("Details", new { id = studentViewModel.Student.Id }));
}
//如果没有通过模型校验，返回Create()操作方法。
return(View());
}
public IHttpActionResult Post([FromBody] StudentDto form)
{
if (ModelState.IsValid)
{
try
{
var student = Mapper.Map <StudentDto, Student>(form);
_studentService.Add(student);
var studentDto = GetStudentDto(student);
return(Created(new Uri(studentDto.Url), studentDto));
}
catch (ArgumentNullException ane)
{
ModelState.AddModelError("", ane.Message);
}
catch (PreexistingEntityException pe)
{
ModelState.AddModelError("", pe.Message);
}
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> Add(int groupId, [FromBody] Student model)
{
model.GroupId = groupId;
model = await _studentService.Add(model);
return(base.Ok(model));
}
public StudentViewModel Add(Guid idEnvironment, StudentViewModel studentViewModel)
{
Student student = _mapper.Map <Student>(studentViewModel);
SystemEnvironment environment = _mapper.Map <SystemEnvironment>(_environmentService.GetById(idEnvironment));
return(_mapper.Map <StudentViewModel>(_studentService.Add(environment, student)));
}
public IActionResult Create(Student student)
{
if (ModelState.IsValid)
{
_studentService.Add(student);
}
return(RedirectToAction("Index"));
}
public IActionResult Student(StudentViewModel viewModel)
{
if (ModelState.IsValid)
{
_studentService.Add(viewModel.Student);
}
return(RedirectToAction("StudentList"));
}
public async Task <ResultMessage <bool> > FinishRegistrationProcess(RegisterUserDTO registerData)
{
try
{
using (IDbContextTransaction transaction = await _context.Database.BeginTransactionAsync())
{
StudentDTO student = Mapping.Mapper.Map <StudentDTO>(registerData);
ResultMessage <RegistrationDTO> res = await _registrationService.GetSingleOrDefault(
reg => reg.RegistrationCode == registerData.RegistrationCode);
RegistrationDTO registration = res.Result;
Mapping.Mapper.Map(registration, student);
byte[] salt = Security.GenerateRandomBytes(Constants.SALT_SIZE);
string saltBase64 = Convert.ToBase64String(salt);
string hash = Security.CreateHash(registerData.Password, salt,
Constants.PASSWORD_HASH_SIZE);
student.PasswordHash = hash;
student.Salt = saltBase64;
student.Rating = 0;
registration.Used = true;
ResultMessage <RegistrationDTO> registrationProcessResult = await _registrationService.Update(registration);
if (!registrationProcessResult.IsSuccess)
{
return(new ResultMessage <bool>(registrationProcessResult.Status, "Registration couldn't been updated." + registrationProcessResult.Message));
}
ResultMessage <StudentDTO> dtoStudent = await _studentService.Add(student);
if (!dtoStudent.IsSuccess)
{
return(new ResultMessage <bool>(dtoStudent.Status, "Registration couldn't been updated." + dtoStudent.Message));
}
transaction.Commit();
return(new ResultMessage <bool>(true, OperationStatus.Success));
}
}
catch (DbUpdateException ex)
{
return(new ResultMessage <bool>(false, _errorHandler.Handle(ex)));
}
}
public Object Add(StudentInput input)
{
var param = new Student {
Id = input.Id, Name = input.Name
};
_studentService.Add(param);
return(param);
}
public IActionResult Create([Bind("ID,LastName,FirstMidName,EnrollmentDate")] Student student)
{
if (ModelState.IsValid)
{
service.Add(student);
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public ActionResult Students_Create([DataSourceRequest] DataSourceRequest request,
global::StudentInternshipManagement.Models.Entities.Student student)
{
if (ModelState.IsValid)
{
_studentService.Add(student);
}
return(Json(new[] { student }.ToDataSourceResult(request, ModelState)));
}
public virtual IActionResult Create([FromBody] Student student)
{
var result = _studentService.Add(student);
if (!result)
{
return(BadRequest("Can't create the requested record."));
}
return(CreatedAtAction(nameof(Get), new { student.Id }, student));
}
public IActionResult InsertSchool([FromBody] Student student)
{
var data = _studentService.Add(student);
if (data.Success)
{
return(Ok(data));
}
return(BadRequest(data.Message));
}
public IActionResult Privacy()
{
Student s = new Student()
{
Ime = "Denis", Prezime = "Music"
};
studentService.Add(s);
return(View());
}
public IActionResult Add(Student student)
{
var result = _studentService.Add(student);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public ActionResult PostStudent([FromBody] Student student)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var item = _service.Add(student);
return(CreatedAtAction("GetStudent", new { id = item.Id }, item));
}
public IActionResult Post([FromBody] Student student)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_studentService.Add(student);
return(CreatedAtAction("Get", new { id = student.Id }, student));
}
public ActionResult Create(StudentModel student)
{
student.Id = Guid.NewGuid().ToString();
if (ModelState.IsValid)
{
var result = mapper.Map <StudentModel, Student>(student);
studentService.Add(result);
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public async Task Handle(AccountCreated notification, CancellationToken cancellationToken)
{
if (notification.Role != Role.Student)
{
return;
}
_studentService.Add(new Student()
{
Email = notification.Email, FirstName = "Andriyan", LastName = "Krastev"
});
}
public ActionResult Register(Student student)
{
try
{
StudentService.Add(student);
return(Content("<script>alert('注册成功！');window.open('" + Url.Content("~/Index/Index") + "', '_self')</script>"));
}
catch (Exception)
{
throw;
}
}
public async Task <ActionResult <Student> > Post(CreateStudentModel studentModel)
{
_logger.LogInfo("Student creation called");
var student = _mapper.Map <Student>(studentModel);
await _studentService.Add(student);
_logger.LogInfo("Student created successfully");
return(CreatedAtAction(nameof(Post), student));
}
public async Task <IActionResult> AddStudentToTeacher(StudentRegisterDto studentRegisterDto, int id)
{
try
{
await _studentService.Add(studentRegisterDto, id);
return(Ok("Öğrenci Başarıyla Kaydedildi"));
}
catch
{
return(BadRequest("Öğrenci Eklenemedi"));
}
}
public IActionResult Post([FromBody] StudentModel student)
{
try
{
_studentService.Add(student.ToDomainModel());
}
catch (System.Exception ex)
{
ModelState.AddModelError("AddStudent", ex.Message);
return(BadRequest(ModelState));
}
return(CreatedAtAction("Get", new { Id = student.Id }, student));
}
public bool Add(Student student)
{
Person person = new Person();
person.Name = student.Person.Name;
person.IdentificationDocument = student.Person.IdentificationDocument;
person.BirthDate = student.Person.BirthDate;
_personService.Add(person);
student.PersonId = person.Id;
student.TypeStudentId = student.TypeStudentId;
_service.Add(student);
return(true);
}
