public async Task <ActionResult> Delete(long id)
{
try
{
QualificationDto qualification = new QualificationDto {
StudentQualificationId = id, StudentId = this.LoggedInUserId, ActionUserName = this.LoggedInUserName
};
var result = await _studentQualificationService.DeleteQualification(qualification);
if (result)
{
return(Json(new { Status = true, Message = Resources.ModelValidations.Message_Qualification_Delete_Success }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { Status = false, Message = Resources.ModelValidations.Message_Qualification_Delete_Fail }, JsonRequestBehavior.AllowGet));
}
}
catch (Exception ex)
{
this.Logger.Error("Delete Qualification", ex);
}
return(Json(new { Status = false, Message = Resources.ModelValidations.Message_Qualification_Delete_Fail }, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> EligibleCourse(int?eid)
{
if (HttpContext.Session["AdminUser"] != null)
{
QualificationDto eligibleCourse = new QualificationDto();
if (eid != null)
{
var eligiblecourseDetails = await dataAccess.GetEligibleCourseByKye(eid);
//ViewBag.eligigbleCourseList = await dataAccess.GetAllQualification();
//ViewBag.mainStreamList = await dataAccess.GetAllMainStream();
return(View(eligiblecourseDetails));
}
else
{
//ViewBag.eligigbleCourseList = await dataAccess.GetAllQualification();
//ViewBag.mainStreamList = await dataAccess.GetAllMainStream();
return(View());
}
}
else
{
ViewData["LoginError"] = "Please Login First";
return(View("Index"));
}
}
/// <summary>
/// Delete Qualification
/// </summary>
/// <param name="qualification"></param>
/// <returns></returns>
public async Task <bool> DeleteQualification(QualificationDto qualification)
{
//soft delete
var apiUrl = UrlExtension.Combine(WebApiBasePath, "/qualification/delete");
var deleteQualification = Mapper.Map <Qualification>(qualification);
var result = await _apiService.PostJsonAsync <Qualification>(apiUrl, deleteQualification);
return(result);
}
public async Task <IActionResult> UpdateQualification(QualificationDto qualificationDto)
{
var user = await _qualificationsService.Update(qualificationDto);
if (user.IsSuccess)
{
return(Ok(user));
}
return(BadRequest(user.ErrorMessage));
}
public static IQualification Create(QualificationDto qualificationDto)
{
var qualification = Ioc.Container.Resolve <IQualification>();
qualification.CreatedAt = qualificationDto.CreatedAt;
qualification.Id = qualificationDto.Id;
qualification.Name = qualificationDto.Name;
qualification.UpdatedAt = qualificationDto.UpdatedAt;
qualification.Subjects = qualificationDto.Subjects.Select(SubjectDtoFactory.Create).ToList();
return(qualification);
}
public async Task <IActionResult> AddNewEmployee(QualificationDto qualificationDto)
{
var user = await _qualificationsService.Add(qualificationDto);
if (user.IsSuccess)
{
return(Ok(user));
}
return(BadRequest(user.ErrorMessage));
}
public async Task <CommonResult> Update(QualificationDto qualificationDto)
{
var updateQualificationDto = await _qualificationsRepository.Update(qualificationDto);
if (updateQualificationDto == null)
{
return(CommonResult <QualificationDto> .Failure <QualificationDto>("Problem occured updating entity."));
}
return(CommonResult <QualificationDto> .Success(qualificationDto));
}
public static QualificationDto GetDto(IQualification qualification)
{
var qualificationDto = new QualificationDto();
qualificationDto.Id = qualification.Id;
qualificationDto.CreatedAt = qualification.CreatedAt;
qualificationDto.Link = qualification.Link;
qualificationDto.Name = qualification.Name;
qualificationDto.UpdatedAt = qualification.UpdatedAt;
qualificationDto.Subjects = qualification.Subjects.Select(SubjectDtoFactory.GetDto).ToList();
return(qualificationDto);
}
public async Task <ActionResult> EligibleCourseInsertUpdate(QualificationDto eligiblecourse)
{
int courseAdd = await dataAccess.InsertUpdateEligibleCourse(eligiblecourse);
if (courseAdd != 0 && eligiblecourse.Eid != 0)
{
return(Json("Update"));
}
else
{
return(Json("Add"));
}
}
/// <summary>
/// Update Qualification
/// </summary>
/// <param name="qualification"></param>
/// <returns></returns>
public async Task <long> UpdateQualification(QualificationDto qualification)
{
var apiUrl = UrlExtension.Combine(WebApiBasePath, "/qualification/update");
var editQualification = Mapper.Map <Qualification>(qualification);
editQualification.Status = (int)QualificationStatus.Pending;
editQualification.ModifiedDate = DateTime.Today;
editQualification.ModifiedBy = qualification.ActionUserName;
//update to DB
var updatedQualification = await _apiService.PostJsonAsync <Qualification, Qualification>(apiUrl, editQualification);
return(updatedQualification.StudentQualificationId);
}
/// <summary>
///
/// </summary>
/// <param name="qualification"></param>
/// <returns></returns>
public async Task <long> RejectQualification(QualificationDto qualification)
{
var apiUrl = UrlExtension.Combine(WebApiBasePath, "/qualification/reject");
var rejectQualification = Mapper.Map <Qualification>(qualification);
rejectQualification.Status = (int)QualificationStatus.Rejected;
rejectQualification.ActionDate = DateTime.Today;
rejectQualification.ActionBy = qualification.ActionUserName;
var updatedQualification = await _apiService.PostJsonAsync <Qualification, Qualification>(apiUrl, rejectQualification);
return(updatedQualification == null ? 0 : updatedQualification.StudentQualificationId);
}
/// <summary>
///
/// </summary>
/// <param name="qualification"></param>
/// <returns></returns>
public async Task <long> ApproveQualification(QualificationDto qualification)
{
//update the status to Approve
var apiUrl = UrlExtension.Combine(WebApiBasePath, "/qualification/approve");
var apporveQualification = Mapper.Map <Qualification>(qualification);
apporveQualification.Status = (int)QualificationStatus.Approved;
apporveQualification.ActionDate = DateTime.Today;
apporveQualification.ActionBy = qualification.ActionUserName;
var updatedQualification = await _apiService.PostJsonAsync <Qualification, Qualification>(apiUrl, apporveQualification);
return(updatedQualification.StudentQualificationId);
}
/// <summary>
/// Validate Qualification for duplicate
/// validate existing and new qualifications
/// </summary>
/// <param name="qualification"></param>
/// <returns></returns>
public async Task <bool> ValidateQualification(QualificationDto qualification)
{
//return false if any duplicate record exists - match all columns
var studentNewQualifications = await GetQualificationsByStudent(new QualificationSearchDto { StudentId = qualification.StudentId });
var studentExistingQualifications = await GetExistingQualificationsByStudent(qualification.StudentId);
var isRecordFound = studentNewQualifications.Concat(studentNewQualifications) //add the two data sets
.Any(q => q.StudentQualificationId != qualification.StudentQualificationId &&
q.StudentId == qualification.StudentId && q.Year == qualification.Year &&
q.QualificationTypeCode == qualification.QualificationTypeCode && q.SubjectCode == qualification.SubjectCode &&
q.Result == qualification.Result && q.SittingCode == qualification.SittingCode);
return(!isRecordFound);
}
public async Task <CommonResult> Add(QualificationDto qualificationDto)
{
if (string.IsNullOrEmpty(qualificationDto.QualificationField))
{
return(CommonResult.Failure("Cannot create user without field provided."));
}
if (string.IsNullOrEmpty(qualificationDto.ApplicationUserId))
{
return(CommonResult.Failure("Cannot create user without user Id provided."));
}
await _qualificationsRepository.Add(qualificationDto);
return(CommonResult.Success());
}
public async Task <IActionResult> UpdateQualification([FromBody] QualificationDto qualification)
{
if (qualification == null)
{
return(BadRequest("QualificationDto object is null"));
}
var qualificationEntity = await _repository.Qualification.GetQualificationAsync(qualification.Id, trackChanges : true);
if (qualificationEntity == null)
{
return(NotFound());
}
_mapper.Map(qualification, qualificationEntity);
await _repository.SaveAsync();
return(NoContent());
}
/// <summary>
/// Add Qualification
/// </summary>
/// <param name="qualification"></param>
/// <returns></returns>
public async Task <long> AddQualification(QualificationDto qualification)
{
Logger.Info("AddQualification :" + qualification.QualificationTypeCode + " " + qualification.StudentId.ToString());
var apiUrl = UrlExtension.Combine(WebApiBasePath, "/qualification/insert");
var newQualification = Mapper.Map <Qualification>(qualification);
//created by /Created Date
newQualification.Status = (int)QualificationStatus.Pending;
newQualification.CreatedDate = DateTime.Today;
newQualification.ActionBy = qualification.ActionUserName;
var newQualificationId = await _apiService.PostJsonAsync <Qualification, long>(apiUrl, newQualification);
return(newQualificationId);
}
public async Task <QualificationDto> Update(QualificationDto qualificationDto)
{
var result = await DbSet.SingleOrDefaultAsync(x => x.Id == qualificationDto.Id);
await UpdateAsync(result);
if (await _dbContext.SaveChangesAsync() == 0)
{
return(null);
}
return(new QualificationDto
{
Id = result.Id,
ApplicationUserId = qualificationDto.ApplicationUserId,
QualificationField = qualificationDto.QualificationField
});
}
public async Task <JsonResult> Reject(long id, long studentId, string remark)
{
QualificationViewModel model = new QualificationViewModel();
try
{
byte[] remarkBytes = Encoding.ASCII.GetBytes(remark);
if (string.IsNullOrWhiteSpace(remark) || remark.Length > MaxRemarkSize || remarkBytes.Length > MaxRemarkSize)
{
return(Json(new { Status = false, Message = Resources.ModelValidations.Message_Qualification_Reject_Remark_Len }, JsonRequestBehavior.AllowGet));
}
else
{
//update remark
var qualification = new QualificationDto {
StudentQualificationId = id, StudentId = studentId, Remark = remark, ActionUserName = this.LoggedInUserName
};
if (User.IsInRole(UserRole.FacultyStaff.ToString()))
{
qualification.FacultyCode = base.LoggedInUserFacultyCode;
}
var result = await this._studentQualificationService.RejectQualification(qualification);
if (result > 0)
{
return(Json(new { Status = true, Message = Resources.ModelValidations.Message_Qualification_Reject_Success }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { Status = false, Message = Resources.ModelValidations.Message_Qualification_Reject_Fail }, JsonRequestBehavior.AllowGet));
}
}
}
catch (Exception ex)
{
this.Logger.Error("Reject Qualification", ex);
return(Json(new { Status = false, Message = string.Format("{0}</br>{1}", Resources.ModelValidations.Message_Qualification_Reject_Fail, ex.Message) }, JsonRequestBehavior.AllowGet));
}
}
public async Task <QualificationDto> Add(QualificationDto qualificationDto)
{
var qualification = new Qualification
{
ApplicationUserId = qualificationDto.ApplicationUserId,
QualificationField = qualificationDto.QualificationField
};
await DbSet.AddAsync(qualification);
if (await _dbContext.SaveChangesAsync() == 0)
{
return(null);
}
qualificationDto.Id = qualification.Id;
return(qualificationDto);
}
public async Task <int> InsertUpdateEligibleCourse(QualificationDto model)
{
try
{
using (connection = Get_Connection())
{
var param = new DynamicParameters();
param.Add("eid", model.Eid, DbType.Int32, ParameterDirection.Input);
param.Add("EligibleCourseName", model.EligibleCourseName, DbType.String, ParameterDirection.Input);
param.Add("College", model.College, DbType.String, ParameterDirection.Input);
param.Add("University", model.University, DbType.String, ParameterDirection.Input);
param.Add("duration", model.duration, DbType.String, ParameterDirection.Input);
var lastInsertedId = await connection.ExecuteScalarAsync <int>("sp_InsertUpdateEligibleCourse", param, commandType : CommandType.StoredProcedure);
return(lastInsertedId);
}
}
catch (Exception ex)
{
throw;
}
}
public async Task <IActionResult> SignUp(QualificationDto qualification)
{
await _db.Mem_EducationDetails.AddAsync(new Mem_EducationDetail
{
CDate = DateTime.UtcNow,
EducationQualificationId = qualification.QualificationId,
PassoutYear = new DateTime(qualification.PassoutYear, 1, 1),
MemberId = qualification.UserId,
Specialization = qualification.Specialization,
UniversityId = qualification.UniversityId,
PhdTopic = qualification.Topic
});
try
{
await _db.SaveChangesAsync();
return(Ok(new { success = "Success" }));
}
catch (System.Exception ex)
{
throw ex;
}
}
public static void UpdateQualification(this Qualification model, QualificationDto modelVm)
{
model.Id = modelVm.Id;
model.Name = modelVm.Name;
model.Code = modelVm.Code;
}
static void Main(string[] args)
{
ProjectDto proj = null;
UserDto manager = null;
UserDto worker1 = null, worker2 = null, worker3 = null;
JobTypeDto firstJobType = null;
QualificationDto firstQual = null;
JobDto job1 = null, job2 = null, job3 = null;
firstJobType = new JobTypeDto
{
Id = Guid.NewGuid(),
Name = "first"
};
firstQual = new QualificationDto
{
EffectivePercent = 100,
Id = Guid.NewGuid(),
Name = "first",
JobType = firstJobType,
Users = new List <UserDto>
{
worker1,
worker2,
worker3
}
};
manager = new UserDto {
Id = Guid.NewGuid(),
FirstName = "Mahager",
LastName = "First",
Login = "******",
Password = "******",
Roles = new List <Role>
{
Role.Manager
},
ManagmentProjects = new List <ProjectDto>
{
proj
}
};
proj = new ProjectDto
{
CreateDate = DateTime.Now,
EarlyTime = DateTime.Now,
LateTime = DateTime.Today,
Name = "Test",
Id = Guid.NewGuid(),
Manager = manager,
Workers = new List <UserDto>
{
worker1,
worker2,
worker3
}
};
new FrontAlgorithm(new FirstlyStratagy()).CreateShedule(proj, proj.EarlyTime.Value, proj.LateTime.Value, PeriodUnit.Minutes);
//var printerToConsole = new PrinterToConsole();
//proj.Print(printerToConsole);
//proj.CreateSchedule(new FrontAlgorithm(new GreedyStratagy()));
//proj.Schedule.Print(printerToConsole);
Console.Read();
}
public async Task <ActionResult> AddUserDetails(UsersDto usr)
{
UserDetailsViewModel userModel = new UserDetailsViewModel();
var User = await dataAccess.InsertUpdateUser(usr);
//var test = GetCourseDetailsOfUser(User);
var userDetails = await dataAccess.GetUserByKey(User);
var lastQualification = await dataAccess.GetEligibleCourseByKye(userDetails.QualificationId);
userModel.id = userDetails.id;
userModel.UserName = userDetails.UserName;
userModel.LastQualification = lastQualification.EligibleCourseName;
userModel.Email = userDetails.Email;
userModel.Contact = userDetails.Contact;
List <CourseDto> courseDetails = new List <CourseDto>();
List <QualificationDto> ObjQualification = new List <QualificationDto>();
var mainStream = await dataAccess.GetMainStreamByKey(userDetails.MainStreamId);
var subStream = await dataAccess.GetSubStreamByKey(userDetails.SubStreamId);
userModel.MainStream = mainStream.MainStreamName;
userModel.SubStream = subStream != null ? subStream.SubStreamName : string.Empty;
courseDetails = await dataAccess.GetCoursForUser(userDetails.MainStreamId, userDetails.SubStreamId);
//if (userDetails.SubStreamId != 0)
//{
// courseDetails = await dataAccess.GetCoursForUser(userDetails.MainStreamId, userDetails.SubStreamId);
//}
foreach (var item in courseDetails)
{
string[] EligibilityIdArray = new string[] { };
if (!string.IsNullOrEmpty(item.EligibleCourseId))
{
EligibilityIdArray = item.EligibleCourseId.Split(',');
}
if (EligibilityIdArray.Count() > 0)
{
foreach (var eligibleCourse in EligibilityIdArray)
{
var eligibleCourseName = await dataAccess.GetEligibleCourseByKye(Convert.ToInt32(eligibleCourse));
if (usr.QualificationId == eligibleCourseName.Eid)
{
QualificationDto objQualificatio = new QualificationDto();
objQualificatio.EligibleCourseName = item.CourseName;
objQualificatio.Eid = item.cid;
objQualificatio.DeleteFlag = item.DeleteFlag;
objQualificatio.College = item.College;
objQualificatio.University = item.University;
objQualificatio.duration = item.duration;
ObjQualification.Add(objQualificatio);
}
}
}
}
if (ObjQualification != null)
{
var result = ObjQualification.GroupBy(q => q.Eid)
.Select(grp => grp.First())
.ToList();
foreach (var item in result)
{
userModel.Course.Add(item);
}
}
if (userModel != null)
{
HttpContext.Session["UserDetails"] = userModel;
}
return(Json(User));
}
/// <summary>
/// Upload Qualification to CU DB
/// </summary>
/// <param name="qualification"></param>
/// <returns></returns>
public async Task <bool> UploadQualification(QualificationDto qualification)
{
//1. upload Qualification to CU
Logger.Info("UploadQualification :" + qualification.QualificationTypeCode + " " + qualification.StudentId.ToString());
var apiCUUrl = UrlExtension.Combine(QualificationAPIPath, "/Qualifications/");
var uploadQualification = Mapper.Map <CUStudentQualification>(qualification);
bool hasCertificate = (qualification.CertificateId != null && qualification.CertificateId > 0);
uploadQualification.SourceCode = "P";
uploadQualification.StatusCode = hasCertificate ? "C" : "U";
CUAllQualification newQualification = await _apiService.PostJsonAsync <CUStudentQualification, CUAllQualification>(apiCUUrl, uploadQualification);
if (newQualification == null)
{
return(false);
}
if (hasCertificate)
{
Logger.Info("UploadQualification> Certificate :");
//2. download Certificate from database
var apiUrl = UrlExtension.Combine(WebApiBasePath, "/qualification/certificate/", qualification.CertificateId.ToString());
HttpResponseMessage response = await _apiService.GetSteamAsync(apiUrl);
if (response == null)
{
return(false);
}
StreamContent content = new StreamContent(await response.Content.ReadAsStreamAsync());
//2. upload certificate to CU
var apiDocumentUrl = UrlExtension.Combine(DocumentAPIPath, "upload");
/*
* '*ApCd' - our application code - not required
* '*PerCd' - our person code
* '*StudId' - the student’s ID
* QualificationId - Hopefully we can include the AllQualificationId returned from /StudentService.svc/Qualifications
* DocumentType - “PEQS” This will be a new document type for us, “Document attached by student post enrolment”
* TheirReference - filename given by user
* TopicCode – “IMPORT”
* SubTopicCode – “QC” We will use the existing subtopic, and add it to the Import Topic “group”
* Subject - reference description given by user * this is an optional field, and I don’t think we have anything to add here ?
* CreatedBy – think this should be the student’s ID (again)
* Content-Length – of file not 100% sure, but isn’t this inferred from the filestream ?
* Content-Type – of file
*/
//content.Headers.Add("*ApCd", "PQES");
//content.Headers.Add("*PerCd", qualification.StudentId.ToString());
content.Headers.Add("*StudId", qualification.StudentId.ToString());
content.Headers.Add("QualificationId", newQualification.AllQualificationId.ToString());
content.Headers.Add("DocumentType", "PQES");
content.Headers.Add("TheirReference", response.Content.Headers.ContentDisposition.FileName);
content.Headers.Add("TopicCode", "IMPORT");
content.Headers.Add("SubTopicCode", "QC");
content.Headers.Add("Subject", "Certificate");
content.Headers.Add("CreatedBy", qualification.StudentId.ToString());
content.Headers.Add("Content-Length", response.Content.Headers.ContentLength.ToString());
content.Headers.Add("Content-Type", response.Content.Headers.ContentType.MediaType);
//TODO:: Return type from document
var result = await _apiService.PostHttpAsync(apiDocumentUrl, content);
if (!result)
{
return(false);
}
}
return(true);
}
