public async Task <IHttpActionResult> Post([FromBody] StudentRegistrationModel value)
{
if (ModelState.IsValid)
{
var student = new Student
{
User = new User
{
FirstName = value.FirstName,
LastName = value.LastName,
Email = value.Email,
Password = value.Password
}
};
try
{
await studentRegistration.RegisterAsync(student);
}
catch (UserExistsException)
{
return(BadRequest("This email address has already been registered."));
}
return(Ok());
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Index(StudentRegistrationModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
try
{
var result = await this.ApiPostAsync(apiPostStudentUri, vm, "StudentApiClient");
if (!result.IsSuccessStatusCode)
{
ViewBag.Name = "Unable to Save At the Moment";
return(View(vm));
}
else
{
ViewBag.Status = $"The student name { vm.StudentName } is record created! ";
RedirectToAction("studentlist", "student");
// return View(vm);
}
}
catch (Exception ex)
{
LogSecurity.Warning("Exception on StudentRegistration Post : ", ex.InnerException.ToString());
//return View(vm);
}
return(View(vm));
//RedirectToAction("studentlist", "student");
}
public ActionResult RegisterAsAlumni(StudentRegistrationModel StudentDetails)
{
if (Session["UserId"] != null)
{
if (ModelState.IsValid)
{
string UserId = "";
UserId = Session["UserId"].ToString();
EducationalDetail details = new EducationalDetail();
TryUpdateModel(details);
details.UserId = Convert.ToInt64(Session["UserId"]);
details.Status = true;
EducationalDetailService.Create(details);
View_UserDetails Userdetails = UserDetailsViewService.GetUserByUserId(Convert.ToInt32(UserId));
UserManager.RemoveFromRole(Userdetails.AspnetUsersId, Userdetails.Role);
UserManager.AddToRole(Userdetails.AspnetUsersId, "Alumni and Faculty");
return(RedirectToAction("UpdateProfile", "Home"));
}
StudentRegistrationModel userdto = new StudentRegistrationModel()
{
Coursecategorys = CourseCategoryService.GetAllCourseCategories(),
};
return(View(userdto));
}
return(RedirectToAction("Login", "Account"));
}
/// <summary>
/// Get All Student List
/// </summary>
/// <returns>Student Registration Model</returns>
public async Task <ResponseModel <StudentRegistrationModel> > GetAllStudentList()
{
ResponseModel <StudentRegistrationModel> returnResponse = new ResponseModel <StudentRegistrationModel>();
var lstStudent = await _studentBusinessService.GetAllStudentList();
if (lstStudent.Count <= 0)
{
returnResponse.ReturnMessage.Add("No Record Found");
returnResponse.ReturnStatus = false;
return(returnResponse);
}
foreach (var item in lstStudent)
{
var temp = new StudentRegistrationModel
{
StudentId = item.StudentId,
StudentName = item.StudentName,
StudentFatherName = item.StudentFatherName,
StudentMotherName = item.StudentMotherName,
StudentRollNumber = item.StudentRollNumber
};
returnResponse.ListObject.Add(temp);
}
return(returnResponse);
}
/// <summary>
/// Create Student
/// </summary>
/// <param name="studentRegistrationModel"></param>
/// <returns>Student Registration</returns>
public async Task <ResponseModel <StudentRegistrationModel> > CreateStudent(StudentRegistrationModel studentRegistrationModel)
{
ResponseModel <StudentRegistrationModel> returnResponse = new ResponseModel <StudentRegistrationModel>();
try
{
IStudentEntity studentEntity = new StudentEntity()
{
StudentId = studentRegistrationModel.StudentId,
StudentName = studentRegistrationModel.StudentName,
StudentFatherName = studentRegistrationModel.StudentFatherName,
StudentMotherName = studentRegistrationModel.StudentMotherName,
StudentRollNumber = studentRegistrationModel.StudentRollNumber
};
returnResponse.ReturnStatus = true;
var result = await _studentBusinessService.Createstudent(studentEntity);
studentRegistrationModel.StudentId = result.StudentId;
returnResponse.Entity = studentRegistrationModel;
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
}
return(returnResponse);
}
public ActionResult Create()
{
StudentRegistrationModel model = new StudentRegistrationModel();
model.AllCourses = dbCourse.List();
model.AllHostels = new HostelManager().FindAll().ToList();
return(View(model));
}
public PartialViewResult StudentRegistration()
{
StudentRegistrationModel userdto = new StudentRegistrationModel()
{
Coursecategorys = CourseCategoryService.GetAllCourseCategories(),
};
return(PartialView("StudentRegistrationForm", userdto));
}
public ActionResult SerachUsers()
{
DateTime CurrentDate = DateTime.Now;
int Year = CurrentDate.Year;
StudentRegistrationModel userdto = new StudentRegistrationModel()
{
Coursecategorys = GenericMetodsservices.GetAllCourseCategories(),
};
return(View(userdto));
}
public ActionResult RegisterAsAlumni()
{
if (Session["UserId"] != null)
{
StudentRegistrationModel userdto = new StudentRegistrationModel()
{
Coursecategorys = CourseCategoryService.GetAllCourseCategories(),
};
return(View(userdto));
}
return(RedirectToAction("Login", "Account"));
}
public async Task <IActionResult> Index(StudentRegistrationModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var access_token = await this.GenerateAccessToekn();
var result = await this.ApiPosAsync(access_token, vm);
//var result = await PostSecertAsync(access_token, vm);
return(RedirectToAction("Index", "Home"));
}
public ActionResult Edit(int id)
{
StudentRegistrationModel model = new StudentRegistrationModel()
{
student = db.Find(id),
AllCourses = dbCourse.List(),
AllHostels = dbHostel.List(),
selectedCourses = db.ListAllStudentRegistrations(id).Select(p => p.Cours).ToList()
};
model.student.Gender = model.student.Gender.Trim();
model.selectedCourseIDs = model.selectedCourses.Select(p => p.ID).ToList();
return(View(model));
}
public ActionResult Create(StudentRegistrationModel model)
{
try
{
// TODO: Add insert logic here
db.Save(model.student);
db.AddCourses(model.student.ID, model.selectedCourseIDs);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ex.Message.Trim();
return(View(model));
}
}
public ActionResult UpdateAlumni()
{
if (Session["UserId"] != null)
{
StudentRegistrationModel userdto = null;
int UserId = Convert.ToInt32(Session["UserId"].ToString());
List <EducationdetailsDTO> educationdetails = EducationalDetailService.GetEducationdetails(UserId);
List <GraduationYear> _GraduationYears = new List <GraduationYear>();
for (int i = 1970; i <= 2015; i++)
{
_GraduationYears.Add(new GraduationYear {
Year = "" + i, GraduationYearId = i
});
}
foreach (var educationdetail in educationdetails)
{
userdto = new StudentRegistrationModel()
{
CourseId = educationdetail.CourseId,
CourseCategoryId = educationdetail.CategoryId,
Batch = educationdetail.Batch,
Coursecategorys = CourseCategoryService.GetAllCourseCategories(),
};
}
int?RoleId = null;
List <View_UserDetails> GetUserRolesCount = UserDetailsViewService.GetUserRolesCount(UserId);
foreach (var Roles in GetUserRolesCount)
{
RoleId = Convert.ToInt32(Roles.RoleId);
}
if (RoleId == 1)
{
return(View(userdto));
}
else if (RoleId == 2)
{
return(RedirectToAction("UpdateFaculty", "Profile"));
}
else if (RoleId == 4)
{
return(RedirectToAction("ViewAllDetails", "Profile"));
}
}
return(RedirectToAction("Login", "Account", new { area = "" }));
}
public async Task PostSecretAsync1(string accessToken, StudentRegistrationModel vm)
{
var userApi = _httpClientFactory.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Post, apiOneUri);
request.Content = new StringContent(JsonConvert.SerializeObject(vm), Encoding.UTF8, "application/json");
var response = await userApi.SendAsync(request);
//if (response.StatusCode == System.Net.HttpStatusCode.OK)
//{
// var body = await response.Content.ReadAsAsync<LoginResponse>();
// return Ok(body);
//}
//return StatusCode((int)response.StatusCode);
}
public ActionResult Details(int id)
{
Student student = new StudentManager().Find(id);
List <StudentEnrollment> studentEnrollments = new StudentCourseManager().FindAllByStudentID(id).ToList();
StudentRegistrationModel studentRegistration = new StudentRegistrationModel()
{
student = student,
selectedCourses = studentEnrollments.Select(p => p.Cours).ToList()
};
if (student == null)
{
return(HttpNotFound());
}
return(View(studentRegistration));
}
public ActionResult Edit(int id, StudentRegistrationModel model)
{
try
{
// TODO: Add update logic here
if (model.selectedCourseIDs != null)
{
db.EditCourses(id, model.selectedCourseIDs);
}
db.Modify(model.student);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(View());
}
}
public async Task <string> PostSecertAsync(string accessToken, StudentRegistrationModel vm)
{
// retrieve secret data from apiOne webApi
var apiOneClient = _httpClientFactory.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Post, apiStudentUri);
request.Content = new StringContent(JsonConvert.SerializeObject(vm), Encoding.UTF8, "application/json");
apiOneClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
apiOneClient.DefaultRequestHeaders.Accept.Clear();
apiOneClient.SetBearerToken(accessToken);
var response = await apiOneClient.PostAsync(apiStudentUri, request.Content);
var content = await response.Content.ReadAsStringAsync();
//var response = await userApi.SendAsync(request);
return(content);
}
public async Task <ResponseModel <StudentRegistrationModel> > GetStudentById(int studentId)
{
ResponseModel <StudentRegistrationModel> responseModel = new ResponseModel <StudentRegistrationModel>();
var student = await _studentBusinessService.GetStudentById(studentId);
var temp = new StudentRegistrationModel
{
StudentId = student.StudentId,
StudentName = student.StudentName,
StudentFatherName = student.StudentFatherName,
StudentMotherName = student.StudentMotherName,
StudentRollNumber = student.StudentRollNumber
};
responseModel.Entity = temp;
responseModel.ListObject.Add(temp);
responseModel.ReturnStatus = true;
return(responseModel);
}
public IResponse <ApiResponse> StudentRegistration()
{
StringValues SubmitedStringifyData = default(string);
StringValues FileData = default(string);
httpContext.Request.Form.TryGetValue("studentObject", out SubmitedStringifyData);
httpContext.Request.Form.TryGetValue("fileDetail", out FileData);
if (SubmitedStringifyData.Count > 0)
{
StudentRegistrationModel studentRegistrationModel = JsonConvert.DeserializeObject <StudentRegistrationModel>(SubmitedStringifyData[0]);
List <Files> fileDetail = JsonConvert.DeserializeObject <List <Files> >(FileData);
if (studentRegistrationModel != null)
{
IFormFileCollection files = httpContext.Request.Form.Files;
string Result = this.registrationService.StudentRegistrationService(studentRegistrationModel, fileDetail, files);
BuildResponse(Result, HttpStatusCode.OK);
}
}
return(apiResponse);
}
/// <summary>
/// Get AllStudentList With Paging Sorting
/// </summary>
/// <param name="searchValue">searchValue</param>
/// <param name="pageNo">page No</param>
/// <param name="pageSize">page Size</param>
/// <param name="sortColumn">sort Column</param>
/// <param name="sortOrder">sort Order</param>
/// <returns>Student data table</returns>
public List <StudentRegistrationModel> GetAllStudentListWithPaging_Sorting(string searchValue, int pageNo, int pageSize, string sortColumn, string sortOrder)
{
List <StudentRegistrationModel> returnResponse = new List <StudentRegistrationModel>();
var lstStudent = _studentBusinessService.GetAllStudentListWithPaging_Sorting(searchValue, pageNo, pageSize, sortColumn, sortOrder);
foreach (var item in lstStudent)
{
var temp = new StudentRegistrationModel
{
StudentId = item.StudentId,
StudentName = item.StudentName,
StudentFatherName = item.StudentFatherName,
StudentMotherName = item.StudentMotherName,
StudentRollNumber = item.StudentRollNumber
};
returnResponse.Add(temp);
}
return(returnResponse);
}
public ActionResult AlumniStep3(StudentRegistrationModel StudentDetails)
{
string userid = "";
if (Session["AspnetUserId"] != null)
{
userid = Session["AspnetUserId"].ToString();
if (ModelState.IsValid)
{
EducationalDetail details = new EducationalDetail();
TryUpdateModel(details);
details.UserId = Convert.ToInt64(Session["UserId"]);
details.Status = true;
ApplicationUser applicationUser = new ApplicationUser();
applicationUser = UserManager.FindById(userid);
details.Email = applicationUser.UserName;
details.MobileNumber = applicationUser.PhoneNumber;
EducationalDetailService.Create(details);
UserDetail userDetails = new UserDetail()
{
Id = Convert.ToInt64(details.UserId),
ProfileInfoPercentage = (int)CustomStatus.ProfileInfoPercentage.EducationDetails,
};
UserService.UpdateUser(userDetails);
UserManager.AddToRole(userid, "Alumini");
return(RedirectToAction("Contactinformation", "Account", new { area = "" }));
}
else
{
StudentRegistrationModel userdto = new StudentRegistrationModel()
{
Coursecategorys = CourseCategoryService.GetAllCourseCategories(),
};
return(View(userdto));
}
}
return(RedirectToAction("Login"));
}
/// <summary>
/// Get All Student List
/// </summary>
/// <returns>Student Registration Model</returns>
public async Task <List <StudentRegistrationModel> > GetAllStudentListCqrs()
{
List <StudentRegistrationModel> returnResponse = new List <StudentRegistrationModel>();
var lstStudent = await _studentBusinessService.GetAllStudentList();
foreach (var item in lstStudent)
{
var temp = new StudentRegistrationModel
{
StudentId = item.StudentId,
StudentName = item.StudentName,
StudentFatherName = item.StudentFatherName,
StudentMotherName = item.StudentMotherName,
StudentRollNumber = item.StudentRollNumber
};
returnResponse.Add(temp);
}
return(returnResponse);
}
public async Task <IActionResult> CreateStudent(StudentRegistrationModel vm)
{
Log.Information("Authenticated user making student/secretcreatestudent API call.");
ResponseModel <StudentRegistrationModel> response;
if (ModelState.IsValid)
{
response = await _studentModelService.CreateStudent(vm);
if (response.ReturnStatus == true)
{
return(Ok(response));
}
else
{
LogSecurity.Warning("Unauthorized access attempted Create {student}", vm.StudentName);
return(BadRequest(response));
}
}
return(BadRequest(vm));
}
public async Task <IActionResult> RegisterStudent(StudentRegistrationModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest("Invalid data."));
}
var password = await userService.RegisterStudent(model.Email);
if (password == null)
{
return(BadRequest("User already exists."));
}
var response = new
{
email = model.Email,
password = password
};
return(Ok(response));
}
public ActionResult UpdateAlumni(StudentRegistrationModel StudentRegistration)
{
if (Session["UserId"] != null)
{
int UserId = Convert.ToInt32(Session["UserId"].ToString());
StudentRegistrationModel userdto = null;
if (ModelState.IsValid)
{
EducationalDetail Education = new EducationalDetail();
TryUpdateModel(Education);
EducationalDetailService.UpdateEducationDetails(UserId, Education);
TempData["Success"] = UtilitiesClass.SuccessMessage;
return(RedirectToAction("Profile", "Profile", new { area = "Alumini" }));
}
List <EducationdetailsDTO> educationdetails = EducationalDetailService.GetEducationdetails(UserId);
List <GraduationYear> _GraduationYears = new List <GraduationYear>();
for (int i = 1970; i <= 2015; i++)
{
_GraduationYears.Add(new GraduationYear {
Year = "" + i, GraduationYearId = i
});
}
foreach (var educationdetail in educationdetails)
{
userdto = new StudentRegistrationModel()
{
CourseId = educationdetail.CourseId,
CourseCategoryId = educationdetail.CategoryId,
Batch = educationdetail.Batch,
Coursecategorys = CourseCategoryService.GetAllCourseCategories(),
};
}
return(View(userdto));
}
return(RedirectToAction("Login", "Account", new { area = "" }));
}
public string SubmitStudentForm(StudentRegistrationModel registrationFormData, List <Files> fileDetail, IFormFileCollection FileCollection, string ProcedureName)
{
string output = null;
ServiceResult ObjServiceResult = validateModalService.ValidateModalFieldsService(typeof(StudentRegistrationModel), registrationFormData);
if (ObjServiceResult.IsValidModal)
{
if (string.IsNullOrEmpty(registrationFormData.ClassDetailUid))
{
registrationFormData.ClassDetailUid = null;
}
if (string.IsNullOrEmpty(registrationFormData.EmailId))
{
registrationFormData.EmailId = null;
}
if (string.IsNullOrEmpty(registrationFormData.Fatheremailid))
{
registrationFormData.Fatheremailid = null;
}
if (string.IsNullOrEmpty(registrationFormData.Mobilenumber))
{
registrationFormData.Mobilenumber = null;
}
registrationFormData.AdmissionDatetime = DateTime.Now;
string ImageName = Guid.NewGuid().ToString();
DbParam[] param = new DbParam[]
{
new DbParam(registrationFormData.StudentUid, typeof(System.String), "_studentUid"),
new DbParam(userDetail.schooltenentId, typeof(System.String), "_schooltenentId"),
new DbParam(registrationFormData.ParentDetailId, typeof(System.String), "_parentDetailId"),
new DbParam(registrationFormData.ClassDetailUid, typeof(System.String), "_classDetailId"),
new DbParam(registrationFormData.FirstName, typeof(System.String), "_FirstName"),
new DbParam(registrationFormData.LastName, typeof(System.String), "_LastName"),
new DbParam(registrationFormData.ImageUrl, typeof(System.String), "_ImageUrl"),
new DbParam(registrationFormData.Dob, typeof(System.DateTime), "_Dob"),
new DbParam(registrationFormData.Age, typeof(System.Int32), "_age"),
new DbParam(registrationFormData.Sex, typeof(System.Boolean), "_sex"),
new DbParam(registrationFormData.LastSchoolName, typeof(System.String), "_LastSchoolName"),
new DbParam(registrationFormData.LastSchoolAddress, typeof(System.String), "_PSAddress"),
new DbParam(registrationFormData.LastSchoolMedium, typeof(System.String), "_PSMedium"),
new DbParam(registrationFormData.CurrentSchoolMedium, typeof(System.String), "_CurrentSchoolMedium"),
new DbParam(registrationFormData.Rollno, typeof(System.Int32), "_rollno"),
new DbParam(registrationFormData.Mobilenumber, typeof(System.String), "_mobilenumber"),
new DbParam(registrationFormData.AlternetNumber, typeof(System.String), "_alternetNumber"),
new DbParam(registrationFormData.EmailId, typeof(System.String), "_emailId"),
new DbParam(registrationFormData.RegistrationNo, typeof(System.String), "_registrationNo"),
new DbParam(registrationFormData.MotherTongue, typeof(System.String), "_motherTongue"),
new DbParam(registrationFormData.Religion, typeof(System.String), "_religion"),
new DbParam(registrationFormData.Catagory, typeof(System.String), "_category"),
new DbParam(registrationFormData.CatagoryDocPath, typeof(System.String), "_categoryDocPath"),
new DbParam(registrationFormData.SiblingRegistrationNo, typeof(System.String), "_siblingRegistrationNo"),
new DbParam(registrationFormData.FatherFirstName, typeof(System.String), "_fatherFirstName"),
new DbParam(registrationFormData.FatherLastName, typeof(System.String), "_fatherLastName"),
new DbParam(registrationFormData.MotherFirstName, typeof(System.String), "_motherFirstName"),
new DbParam(registrationFormData.MotherLastName, typeof(System.String), "_motherLastName"),
new DbParam(registrationFormData.LocalGuardianFullName, typeof(System.String), "_localguardianfullname"),
new DbParam(registrationFormData.FatherMobileno, typeof(System.String), "_fathermobileno"),
new DbParam(registrationFormData.MotherMobileno, typeof(System.String), "_mothermobileno"),
new DbParam(registrationFormData.LocalGuardianMobileno, typeof(System.String), "_localguardianmobileno"),
new DbParam(registrationFormData.FullAddress, typeof(System.String), "_fulladdress"),
new DbParam(registrationFormData.City, typeof(System.String), "_city"),
new DbParam(registrationFormData.Pincode, typeof(System.String), "_pincode"),
new DbParam(registrationFormData.State, typeof(System.String), "_state"),
new DbParam(registrationFormData.Fatheremailid, typeof(System.String), "_fatheremailid"),
new DbParam(registrationFormData.Motheremailid, typeof(System.String), "_motheremailid"),
new DbParam(registrationFormData.LocalGuardianemailid, typeof(System.String), "_localguardianemailid"),
new DbParam(registrationFormData.Fatheroccupation, typeof(System.String), "_fatheroccupation"),
new DbParam(registrationFormData.Motheroccupation, typeof(System.String), "_motheroccupation"),
new DbParam(registrationFormData.Fatherqualification, typeof(System.String), "_fatherQualification"),
new DbParam(registrationFormData.Motherqualification, typeof(System.String), "_motherQualification"),
new DbParam(registrationFormData.LastClass, typeof(System.String), "_LastClass"),
new DbParam(userDetail.UserId, typeof(System.String), "_CreatedBy"),
new DbParam(registrationFormData.ParentRecordExist, typeof(System.Boolean), "_ParentRecordExist"),
new DbParam(registrationFormData.ExistingNumber, typeof(System.String), "_ExistingNumber"),
new DbParam(registrationFormData.IsQuickRegistration, typeof(System.Boolean), "_IsQuickRegistration")
};
output = db.ExecuteNonQuery(ProcedureName, param, true);
if (!string.IsNullOrEmpty(output) && output.IndexOf("Fail") == -1)
{
if (FileCollection.Count > 0)
{
string FolderPath = Path.Combine(this.currentSession.FileUploadFolderName,
ApplicationConstant.Student,
output);
List <Files> files = this.fileService.SaveFile(FolderPath, fileDetail, FileCollection, output);
if (files != null && files.Count > 0)
{
DataSet fileDs = this.beanContext.ConvertToDataSet <Files>(files);
if (fileDs != null && fileDs.Tables.Count > 0 && fileDs.Tables[0].Rows.Count > 0)
{
DataTable table = fileDs.Tables[0];
table.TableName = "Files";
db.InsertUpdateBatchRecord("sp_Files_InsUpd", table);
output = "Record inserted successfully.";
}
}
else
{
///========== Log information ====================
output = "Record updated successfully.";
}
}
}
}
else
{
output = JsonConvert.SerializeObject(ObjServiceResult.ErrorResultedList);
}
return(output.ToString());
}
public ActionResult UpdateAlumni()
{
if (Session["UserId"] != null)
{
StudentRegistrationModel userdto = null;
int UserId = Convert.ToInt32(Session["UserId"].ToString());
List<EducationdetailsDTO> educationdetails = EducationalDetailService.GetEducationdetails(UserId);
List<GraduationYear> _GraduationYears = new List<GraduationYear>();
for (int i = 1970; i <= 2015; i++)
_GraduationYears.Add(new GraduationYear { Year = "" + i, GraduationYearId = i });
foreach (var educationdetail in educationdetails)
{
userdto = new StudentRegistrationModel()
{
CourseId = educationdetail.CourseId,
CourseCategoryId = educationdetail.CategoryId,
Batch = educationdetail.Batch,
Coursecategorys = CourseCategoryService.GetAllCourseCategories(),
};
}
int? RoleId = null;
List<View_UserDetails> GetUserRolesCount = UserDetailsViewService.GetUserRolesCount(UserId);
foreach (var Roles in GetUserRolesCount)
{
RoleId = Convert.ToInt32(Roles.RoleId);
}
if (RoleId == 1)
{
return View(userdto);
}
else if (RoleId == 2)
{
return RedirectToAction("UpdateFaculty", "Profile");
}
else if (RoleId == 4)
{
return RedirectToAction("ViewAllDetails", "Profile");
}
}
return RedirectToAction("Login", "Account", new { area = "" });
}
public ActionResult UpdateAlumni(StudentRegistrationModel StudentRegistration)
{
if (Session["UserId"] != null)
{
int UserId = Convert.ToInt32(Session["UserId"].ToString());
StudentRegistrationModel userdto = null;
if (ModelState.IsValid)
{
EducationalDetail Education = new EducationalDetail();
TryUpdateModel(Education);
EducationalDetailService.UpdateEducationDetails(UserId, Education);
TempData["Success"] = UtilitiesClass.SuccessMessage;
return RedirectToAction("Profile", "Profile", new { area = "Alumini" });
}
List<EducationdetailsDTO> educationdetails = EducationalDetailService.GetEducationdetails(UserId);
List<GraduationYear> _GraduationYears = new List<GraduationYear>();
for (int i = 1970; i <= 2015; i++)
_GraduationYears.Add(new GraduationYear { Year = "" + i, GraduationYearId = i });
foreach (var educationdetail in educationdetails)
{
userdto = new StudentRegistrationModel()
{
CourseId = educationdetail.CourseId,
CourseCategoryId = educationdetail.CategoryId,
Batch = educationdetail.Batch,
Coursecategorys = CourseCategoryService.GetAllCourseCategories(),
};
}
return View(userdto);
}
return RedirectToAction("Login", "Account", new { area = "" });
}
public string StudentRegistrationService(StudentRegistrationModel registrationFormData, List <Files> fileDetail, IFormFileCollection files)
{
return(SubmitStudentForm(registrationFormData, fileDetail, files, "sp_RegisterStudent"));
}
public IActionResult Registration(StudentRegistrationModel studentRegistrationModel)
{
studentRegistrationModel.createRegistration();
return(Redirect("/Home/Index"));
}
public string QuickStudentRegistrationService(QuickRegistrationModal quickRegistrationModal, List <Files> fileDetail, IFormFileCollection files)
{
string Result = default(string);
if (quickRegistrationModal.Type == "student")
{
StudentRegistrationModel registrationFormData = new StudentRegistrationModel();
if (!string.IsNullOrEmpty(quickRegistrationModal.ClassDetailUid))
{
registrationFormData.ClassDetailUid = quickRegistrationModal.ClassDetailUid;
}
else
{
Result = " Class or section";
}
if (!string.IsNullOrEmpty(quickRegistrationModal.Class))
{
registrationFormData.Class = quickRegistrationModal.Class;
}
else
{
Result = " Class or section";
}
if (!string.IsNullOrEmpty(quickRegistrationModal.Fatherfirstname))
{
registrationFormData.FatherFirstName = quickRegistrationModal.Fatherfirstname;
}
else
{
Result = " Father name";
}
registrationFormData.FatherLastName = quickRegistrationModal.Fatherlastname;
if (!string.IsNullOrEmpty(quickRegistrationModal.Motherfirstname))
{
registrationFormData.MotherFirstName = quickRegistrationModal.Motherfirstname;
}
else
{
Result = " Mother name";
}
registrationFormData.MotherLastName = quickRegistrationModal.Motherlastname;
if (!string.IsNullOrEmpty(quickRegistrationModal.MobileNumber))
{
registrationFormData.FatherMobileno = quickRegistrationModal.MobileNumber;
}
else
{
Result = " Father Mobile no.#";
}
if (!string.IsNullOrEmpty(quickRegistrationModal.Class))
{
registrationFormData.FirstName = quickRegistrationModal.Studentfirstname;
}
else
{
Result = " Student name";
}
registrationFormData.LastName = quickRegistrationModal.Studentlastname;
if (string.IsNullOrEmpty(Result))
{
Result = SubmitStudentForm(registrationFormData, fileDetail, files, "sp_RegisterStudent");
}
else
{
Result = "Invalid" + Result;
}
}
else
{
RegistrationFormData registrationFormData = new RegistrationFormData();
if (!string.IsNullOrEmpty(quickRegistrationModal.FirstName))
{
registrationFormData.FirstName = quickRegistrationModal.FirstName;
}
else
{
Result = " First name";
}
registrationFormData.LastName = quickRegistrationModal.LastName;
if (!string.IsNullOrEmpty(quickRegistrationModal.MobileNumber))
{
registrationFormData.MobileNumber = quickRegistrationModal.MobileNumber;
}
else
{
Result = " Mobile no.#";
}
if (quickRegistrationModal.Type == "faculty")
{
registrationFormData.Designation = "Faculty";
}
else
{
registrationFormData.Designation = "Other";
}
if (string.IsNullOrEmpty(Result))
{
Result = RegisterStaffFaculty(registrationFormData, fileDetail, files);
}
else
{
Result = "Invalid" + Result;
}
}
return(Result);
}
