public bool InsertTeacherRecord(AddTeacherModel model)
{
using (SqlConnection connection = new SqlConnection(WebConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
{
SqlCommand command = new SqlCommand("AddNewTeacher", connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@Name", model.Name);
command.Parameters.AddWithValue("@Email", model.Email);
command.Parameters.AddWithValue("@CourseTeaching", model.CourseTeaching);
command.Parameters.AddWithValue("@CourseId", model.CourseId);
command.Parameters.AddWithValue("@Username", model.Username);
command.Parameters.AddWithValue("@Password", model.Password);
connection.Open();
try
{
int i = command.ExecuteNonQuery();
connection.Close();
if (i > 0)
{
return(true);
}
}
catch (Exception e)
{
return(false);
}
}
return(false);
}
public async Task<IActionResult> AddTeachersToAssignment([FromBody] AddTeacherModel model)
{
var assignment = _internshipAssignments.GetInternshipAssignmentById(model.AssignmentId);
if (model.TeacherIds == "0")
{
_internshipAssignments.RemoveAllTeachersFromAssignment(assignment);
return Ok();
}
List<int> teacherids = ConvertTeacherIdStringListToInt(model.TeacherIds);
List<User> teachers = new List<User>();
foreach (int id in teacherids)
{
var teacher = await _userManager.FindByIdAsync(id.ToString());
teachers.Add(teacher);
}
_internshipAssignments.AddTeacherToAssignment(teachers, assignment);
_internshipAssignments.UpdateStatus(model.AssignmentId, Status.Behandeling, "");
_internshipAssignments.UpdateTeacherStatusAssignment(model.AssignmentId, TeacherStatus.LectorToegewezen);
return Ok();
}
public IActionResult Add(AddTeacherModel shift)
{
TeacherBusiness shiftBusiness = new TeacherBusiness();
var result = shiftBusiness.AddTeacher(shift);
return(Ok(result));
}
public async Task <ActionResult> Add(AddTeacherModel Teacher)
{
Teacher.CreatedBy = _userSessionHelper.GetUserSession().UserName;
string apiUrl = _appUrlHelper.GetApiUrl(ApiUrlPath.TEACHER_ADD);
var result = await HttpUtilities.PostAsyncApi <ReturnResult <Teacher> >(apiUrl, JsonConvert.SerializeObject(Teacher));
return(Json(result));
}
public ActionResult AddTeacher(AddTeacherModel model, string returnUrl)
{
var objUtilities = new Utilities.Utilities();
bool validateInsertTeacherRecord = objUtilities.InsertTeacherRecord(model);
if (validateInsertTeacherRecord)
{
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "UserName or CourseId Already exists.");
return(View());
}
public async Task AddTeachersToAssignmentShouldReturnOkIfSuccessful(string ids)
{
SetUpMockForUpdateStatusSystem();
AddTeacherModel addTeacherModel = new AddTeacherModel
{
AssignmentId = 1,
TeacherIds = ids
};
_internshipAssignmentMock.Setup(_internshipAssignmentMock => _internshipAssignmentMock.GetInternshipAssignmentById(It.IsAny <int>()))
.Returns(GetInternshipAssignment());
var action = await _assignmentsController.AddTeachersToAssignment(addTeacherModel);
var result = (OkResult)action;
Assert.That(result.StatusCode, Is.EqualTo(200));
}
public ReturnResult <Teacher> Add(AddTeacherModel teacher)
{
DbProvider dbProvider = new DbProvider();
string outCode = String.Empty;
string outMessage = String.Empty;
StoredProcedureConfigs <Teacher> storedProcedureConfigs = new StoredProcedureConfigs <Teacher>();
dbProvider.SetQuery(storedProcedureConfigs._INSERT_SINGLE_STORED_PROCEDURE, CommandType.StoredProcedure)
.SetParameter("Name", SqlDbType.NVarChar, teacher.Name, ParameterDirection.Input)
.SetParameter("Status", SqlDbType.Int, teacher.Status, ParameterDirection.Input)
.SetParameter("PhoneNumber", SqlDbType.Int, teacher.PhoneNumber, ParameterDirection.Input)
.SetParameter("CreatedBy", SqlDbType.NVarChar, teacher.CreatedBy, ParameterDirection.Input)
.SetParameter("ERROR_CODE", SqlDbType.NVarChar, DBNull.Value, 100, ParameterDirection.Output)
.SetParameter("ERROR_MESSAGE", SqlDbType.NVarChar, DBNull.Value, 400, ParameterDirection.Output)
.ExcuteNonQuery()
.Complete();
dbProvider.GetOutValue("ERROR_CODE", out outCode)
.GetOutValue("ERROR_MESSAGE", out outMessage);
return(new ReturnResult <Teacher>()
{
ErrorCode = outCode,
ErrorMessage = outMessage,
});
}
public IHttpActionResult AddGV(AddTeacherModel model)
{
IHttpActionResult httpActionResult;
ErrorModel errors = new ErrorModel();
Teacher t = new Teacher();
t = _db.Teacher.FirstOrDefault(m => m.Id == model.Id_GV);
Classes l = new Classes();
l = _db.Class.FirstOrDefault(m => m.Id == model.Id_Lop);
if (t == null)
{
errors.Add("Không tìm thấy Giáo viên có ID là : " + model.Id_GV);
}
if (l == null)
{
errors.Add("Không tìm thấy Lớp có ID là : " + model.Id_Lop);
}
if (errors.Errors.Count == 0)
{
l.DanhSachGV.Add(t);
this._db.SaveChanges();
ClassModel viewModel = new ClassModel(l);
httpActionResult = Ok(viewModel);
}
else
{
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.NotFound, errors);
}
return(httpActionResult);
}
public async Task <bool> AddTeacherAsync(AddTeacherModel profile)
{
try
{
DbUser user = new DbUser
{
UserName = profile.Email /*profile.UserName*/,
Email = profile.Email,
PhoneNumber = profile.PhoneNumber,
};
BaseProfile prof = new BaseProfile
{
Name = profile.Name,
LastName = profile.LastName,
Surname = profile.Surname,
Adress = profile.Adress,
DateOfBirth = Convert.ToDateTime(profile.DateOfBirth),
PassportString = profile.PassportString,
IdentificationCode = profile.IdentificationCode
};
string password = PasswordGenerator.GenerationPassword();
if (profile.Rolename == null)
{
return(false);
}
await _userManager.CreateAsync(user, password);
if (profile.Rolename.Contains("Teacher"))
{
await _userManager.AddToRoleAsync(user, "Teacher");
}
if (profile.Rolename.Contains("Director"))
{
await _userManager.AddToRoleAsync(user, "Director");
}
if (profile.Rolename.Contains("Curator"))
{
await _userManager.AddToRoleAsync(user, "Curator");
}
if (profile.Rolename.Contains("DDeputy"))
{
await _userManager.AddToRoleAsync(user, "DDeputy");
}
if (profile.Rolename.Contains("DepartmentHead"))
{
await _userManager.AddToRoleAsync(user, "DepartmentHead");
}
if (profile.Rolename.Contains("CycleCommisionHead"))
{
await _userManager.AddToRoleAsync(user, "CycleCommisionHead");
}
if (profile.Rolename.Contains("StudyRoomHead"))
{
await _userManager.AddToRoleAsync(user, "StudyRoomHead");
}
prof.Id = user.Id;
await _context.BaseProfiles.AddAsync(prof);
await _context.SaveChangesAsync();
await _context.TeacherProfiles.AddAsync(new TeacherProfile
{
Id = prof.Id,
//Degree = profile.Degree
});
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public ReturnResult <Teacher> AddTeacher(AddTeacherModel mouse)
{
return(TeacherDAL.Add(mouse));
}
