protected override ValidationResult IsValid(object Date, ValidationContext validationContext)
{
AssessmentResult result = (AssessmentResult)validationContext.ObjectInstance;
string msg = "";
if ((result == null) || (result.AssessmentID == null))
{
msg = "Assessment result object invalid, cannot complete validation";
return(new ValidationResult(msg));
}
// Calculate days since assessment
TimeSpan daysSinceAssessment = DateTime.Now - result.AssessmentDate;
if (daysSinceAssessment.TotalDays > 180)
{
msg = $"Assessment date: {result.AssessmentDate.ToShortDateString()} is older than six months";
}
else if (daysSinceAssessment.TotalDays < 0)
{
msg = $"Assessment date: {result.AssessmentDate.ToShortDateString()} is in the future";
}
else
{
return(ValidationResult.Success);
}
return(new ValidationResult(msg));
}
protected override ValidationResult IsValid(object AssessmentResult, ValidationContext validationContext)
{
// Get current Assessment Result object
AssessmentResult assessmentResult = (AssessmentResult)validationContext.ObjectInstance;
// Check if AssessMentResult.Assessment ID is set. If not, exit without validation
if (assessmentResult.AssessmentID == null)
{
// Cannot complete validation - exit
return(new ValidationResult("AssessmentResult object not populated properly. Cannot complete validation."));
}
// Get DB context
var _db = (SchoolDbContext)validationContext
.GetService(typeof(SchoolDbContext));
// Get the assessment for this assessment result
IList <Assessment> assessments = _db.Assessments.AsNoTracking().ToList();
Assessment assessment = assessments.Where(a => a.AssessmentID == assessmentResult.AssessmentID)
.Select(a => a).FirstOrDefault();
// Check that the assessment result mark is less than the assessment total mark
if (assessmentResult.AssessmentResultMark <= assessment.AssessmentTotalMark)
{
return(ValidationResult.Success);
}
string valReturn = $"Assessment result {assessmentResult.AssessmentResultMark} must be less than or equal to {assessment.AssessmentTotalMark}";
return(new ValidationResult(valReturn));
}
public ModelInvokeResult <AssessmentResultPK> Nullify(string strId)
{
ModelInvokeResult <AssessmentResultPK> result = new ModelInvokeResult <AssessmentResultPK> {
Success = true
};
try
{
List <IBatisNetBatchStatement> statements = new List <IBatisNetBatchStatement>();
AssessmentResult assessmentResult = new AssessmentResult {
Id = Int32.Parse(strId), Status = 0
};
/***********************begin 自定义代码*******************/
assessmentResult.OperatedBy = NormalSession.UserId.ToGuid();
assessmentResult.OperatedOn = DateTime.Now;
assessmentResult.DataSource = GlobalManager.DIKey_00012_ManualEdit;
/***********************end 自定义代码*********************/
statements.Add(new IBatisNetBatchStatement {
StatementName = assessmentResult.GetUpdateMethodName(), ParameterObject = assessmentResult.ToStringObjectDictionary(false), Type = SqlExecuteType.UPDATE
});
/***********************begin 自定义代码*******************/
/***********************此处添加自定义代码*****************/
/***********************end 自定义代码*********************/
BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(statements);
result.instance = new AssessmentResultPK {
Id = Int32.Parse(strId)
};
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.Message;
}
return(result);
}
public async Task <IActionResult> Edit(string id, [Bind("AssessmentResultID,AssessmentResultDescription,AssessmentResultMark,StudentID,ProgrammeID,AssessmentDate,ModuleID,AssessmentID")] AssessmentResult assessmentResult)
{
if (id != assessmentResult.AssessmentResultID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
assessmentResultRepository.Update(assessmentResult);
await assessmentResultRepository.SaveChangesAsync();
}
catch (DataAccessException e)
{
if (!AssessmentResultExists(assessmentResult.AssessmentResultID))
{
return(NotFound());
}
ViewBag.ErrorMsg = ErrorProcessing.ProcessException("Data Access exception. ", e);
return(RedirectToAction("Unknown", "Error"));
}
catch (Exception e)
{
ViewBag.ErrorMsg = ErrorProcessing.ProcessException("General exception. ", e);
return(RedirectToAction("Unknown", "Error"));
}
return(RedirectToAction(nameof(ShowAll)));
}
return(View(assessmentResult));
}
public async Task <IActionResult> OnGetAsync(string id)
{
AssessmentResult = await _db.AssessmentResults.FindAsync(id);
if (AssessmentResult == null)
{
return(NotFound());
}
return(Page());
}
public string SaveAssessmentResult(DataTable dtResultDetails, AssessmentResult assessmentResult)
{
string totalScore = "";
SqlConnection objConnection = null;
SqlCommand objCommand = null;
string ConnStr = string.Empty;
try
{
ConnStr = DBConstants.GetDBConnectionString();
objConnection = new SqlConnection(ConnStr);
objConnection.Open();
Master master = new Master();
foreach (DataRow row in dtResultDetails.Rows)
{
row["CreatedBy"] = master.GetEmployeeIDByEmailID();
//row["LastEditedBy"] = master.GetEmployeeIDByEmailID();
}
objCommand = new SqlCommand(SPNames.AddAssessmentResult, objConnection);
objCommand.CommandType = CommandType.StoredProcedure;
SqlParameter[] sqlParam = new SqlParameter[10];
sqlParam[0] = objCommand.Parameters.AddWithValue(SPParameter.AssessmentPaperId, assessmentResult.AssessmentPaperId);
sqlParam[1] = objCommand.Parameters.AddWithValue(SPParameter.EmployeeID, assessmentResult.EmployeeId);
sqlParam[2] = objCommand.Parameters.AddWithValue(SPParameter.IsActive, assessmentResult.IsActive);
sqlParam[3] = objCommand.Parameters.AddWithValue(SPParameter.CreatedById, master.GetEmployeeIDByEmailID());
sqlParam[4] = objCommand.Parameters.AddWithValue(SPParameter.CreatedByDate, assessmentResult.CreatedOn);
sqlParam[5] = objCommand.Parameters.AddWithValue(SPParameter.LastModifiedById, master.GetEmployeeIDByEmailID());
sqlParam[6] = objCommand.Parameters.AddWithValue(SPParameter.LastModifiedDate, assessmentResult.LastEditedOn);
sqlParam[7] = objCommand.Parameters.AddWithValue(SPParameter.AssessmentResultDetails, dtResultDetails);
sqlParam[7].SqlDbType = SqlDbType.Structured;
sqlParam[8] = objCommand.Parameters.AddWithValue(SPParameter.TotalScore, 0);
sqlParam[8].Direction = ParameterDirection.Output;
sqlParam[9] = objCommand.Parameters.AddWithValue(SPParameter.Status, 0);
sqlParam[9].Direction = ParameterDirection.Output;
objCommand.ExecuteNonQuery();
totalScore = Convert.ToString(sqlParam[8].Value);
totalScore += "," + Convert.ToString(sqlParam[9].Value);
}
catch (Exception ex)
{
throw new RaveHRException(ex.Message, ex, Sources.DataAccessLayer, "SaveAssessmentResult", "SaveAssessmentResult", EventIDConstants.TRAINING_DATA_ACCESS_LAYER);
}
finally
{
if (objConnection.State == ConnectionState.Open)
{
objConnection.Close();
}
}
return(totalScore);
}
private AssessmentResult ConvertAssessmentResultViewModelToDomain(AssessmentResultViewModel assessmentResultViewModel)
{
AssessmentResult assessmentResult = new AssessmentResult();
assessmentResult.AssessmentPaperId = assessmentResultViewModel.AssessmentPaperId;
assessmentResult.EmployeeId = assessmentResultViewModel.EmployeeId;
assessmentResult.AssessmentDate = assessmentResultViewModel.AssessmentDate;
assessmentResult.IsActive = true;
assessmentResult.CreatedOn = DateTime.Now;
assessmentResult.LastEditedOn = DateTime.Now;
return(assessmentResult);
}
/// <summary>
/// Assesses a Patient's age and no. of trigger terms to determine
/// the assessment result.
/// </summary>
/// <param name="patient"></param>
/// <param name="triggerCount"></param>
/// <returns></returns>
private AssessmentResult AssesPersonalData(PatientModel patient,
int triggerCount)
{
var patientAge = GetAge(patient);
var riskLevel = patientAge > 30
? AssessPatientOver30(patient, triggerCount)
: AssessPatientUnder30(patient, triggerCount);
var result = new AssessmentResult(patient.Id, riskLevel);
return(result);
}
public ModelInvokeResult <AssessmentResultPK> NullifyEx(string strIds, string strOldManId, string strWorkItems)
{
ModelInvokeResult <AssessmentResultPK> result = new ModelInvokeResult <AssessmentResultPK> {
Success = true
};
try
{
string[] arrIds = strIds.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
string[] arrWorkItems = strWorkItems.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (arrIds.Length == 0)
{
result.Success = false;
result.ErrorCode = 59996;
return(result);
}
List <IBatisNetBatchStatement> statements = new List <IBatisNetBatchStatement>();
foreach (string strId in arrIds)
{
AssessmentResult assessmentResult = new AssessmentResult {
Id = Int32.Parse(strId), Status = 0
};
/***********************begin 自定义代码*******************/
assessmentResult.OperatedBy = NormalSession.UserId.ToGuid();
assessmentResult.OperatedOn = DateTime.Now;
assessmentResult.DataSource = GlobalManager.DIKey_00012_ManualEdit;
/***********************end 自定义代码*********************/
statements.Add(new IBatisNetBatchStatement {
StatementName = assessmentResult.GetUpdateMethodName(), ParameterObject = assessmentResult.ToStringObjectDictionary(false), Type = SqlExecuteType.UPDATE
});
}
BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(statements);
/***********************begin 自定义代码*******************/
string sql = "delete from Pam_WorkPlan where OldManId='" + strOldManId + "' and WorkItem in ('" + string.Join("','", arrWorkItems) + "') and PlanDate>GETDATE()";
BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(sql);
/***********************end 自定义代码*********************/
/***********************begin 重新生成工作执行表*********************/
SPParam spParam = new { }.ToSPParam();
spParam["OldManId"] = strOldManId.ToGuid();
spParam["BatchFlag"] = 0;
BuilderFactory.DefaultBulder().ExecuteSPNoneQuery("SP_Pam_GenDailyWorkExcute", spParam);
/***********************end 重新生成工作执行表*********************/
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.Message;
}
return(result);
}
public InvokeResult CreateAssessment(string strOldManId, IList <AssessmentItem> assessmentItems)
{
InvokeResult result = new InvokeResult {
Success = true
};
try
{
List <IBatisNetBatchStatement> statements = new List <IBatisNetBatchStatement>();
AssessmentResult assessmentResult = new AssessmentResult();
foreach (AssessmentItem assessmentItem in assessmentItems)
{
/***********************begin 自定义代码*******************/
assessmentResult.Id = null;
assessmentResult.OperatedBy = NormalSession.UserId.ToGuid();
assessmentResult.OperatedOn = DateTime.Now;
assessmentResult.DataSource = GlobalManager.DIKey_00012_ManualEdit;
assessmentResult.OldManId = strOldManId.ToGuid();
assessmentResult.WorkItem = assessmentItem.WorkItem;
assessmentResult.WorkSchedule = assessmentItem.WorkSchedule;
assessmentResult.Workload = assessmentItem.Workload;
assessmentResult.RemindFlag = assessmentItem.RemindFlag;
assessmentResult.RemindRepeats = assessmentItem.RemindRepeats;
assessmentResult.PlayRepeats = assessmentItem.PlayRepeats;
assessmentResult.CheckDescription = assessmentItem.Remark;
/***********************end 自定义代码*********************/
statements.Add(new IBatisNetBatchStatement {
StatementName = assessmentResult.GetCreateMethodName(), ParameterObject = assessmentResult.ToStringObjectDictionary(false), Type = SqlExecuteType.INSERT
});
/***********************begin 自定义代码*******************/
/***********************此处添加自定义代码*****************/
/***********************end 自定义代码*********************/
}
if (statements.Count > 0)
{
BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(statements);
}
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.Message;
}
return(result);
}
public async Task <IActionResult> Submit(AssessmentResult assessmentResult)
{
try
{
string assessmentResultId = await GetAssessmentResultId();
assessmentResult.AssessmentResultID = assessmentResultId;
if (ModelState.IsValid)
{
await assessmentResultRepository.AddAsync(assessmentResult);
await assessmentResultRepository.SaveChangesAsync();
return(RedirectToAction(nameof(ShowAll)));
}
//Student std = _context.Students
// .Include(m => m.Programme)
// .FirstOrDefault(m => m.StudentID == assessmentResult.StudentID);
var student = await studentRepository.FindByIdIncludeProgrammeAsync(assessmentResult.StudentID);
if (student == null)
{
ViewBag.StudentList = await studentRepository.AllAsync();
}
else
{
ViewBag.StudentId = student.StudentID;
ViewBag.StudentFullName = student.FirstName + " " + student.SurName;
}
return(View(assessmentResult));
}
catch (DataAccessException e)
{
ViewBag.ErrorMsg = ErrorProcessing.ProcessException("Data Access exception. ", e);
return(RedirectToAction("Unknown", "Error"));
}
catch (Exception e)
{
ViewBag.ErrorMsg = ErrorProcessing.ProcessException("General exception. ", e);
return(RedirectToAction("Unknown", "Error"));
}
}
public InvokeResult NullifySelected(string strIds)
{
InvokeResult result = new InvokeResult {
Success = true
};
try
{
List <IBatisNetBatchStatement> statements = new List <IBatisNetBatchStatement>();
string[] arrIds = strIds.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (arrIds.Length == 0)
{
result.Success = false;
result.ErrorCode = 59996;
return(result);
}
string statementName = new AssessmentResult().GetUpdateMethodName();
foreach (string strId in arrIds)
{
AssessmentResult assessmentResult = new AssessmentResult {
Id = Int32.Parse(strId), Status = 0
};
/***********************begin 自定义代码*******************/
assessmentResult.OperatedBy = NormalSession.UserId.ToGuid();
assessmentResult.OperatedOn = DateTime.Now;
assessmentResult.DataSource = GlobalManager.DIKey_00012_ManualEdit;
/***********************end 自定义代码*********************/
statements.Add(new IBatisNetBatchStatement {
StatementName = statementName, ParameterObject = assessmentResult.ToStringObjectDictionary(false), Type = SqlExecuteType.UPDATE
});
}
BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(statements);
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.Message;
}
return(result);
}
public async Task <IActionResult> OnGetAsync(string id)
{
AssessmentResult = await _db.AssessmentResults.FindAsync(id);
if (AssessmentResult == null)
{
return(NotFound());
}
StudentList = await _db.Students.AsNoTracking().ToListAsync();
ModuleList = await _db.Modules.AsNoTracking().ToListAsync();
ProgrammeList = await _db.Programmes.AsNoTracking().ToListAsync();
AssessmentList = await _db.Assessments.AsNoTracking().ToListAsync();
var students = StudentList.Where(s => s.StudentID == AssessmentResult.StudentID);
StudentName = students.FirstOrDefault().ToString();
AssessmentResult.ProgrammeID = students.First().ProgrammeID;
ProgrammeName = ProgrammeList.Where(p => p.ProgrammeID == AssessmentResult.ProgrammeID)
.Select(p => p)
.FirstOrDefault().ProgrammeName;
ModuleName = ModuleList.Where(s => s.ModuleID == AssessmentResult.ModuleID)
.First().ModuleName;
AssessmentName = AssessmentList.Where(s => s.AssessmentID == AssessmentResult.AssessmentID)
.First().AssessmentName;
return(Page());
}
public InvokeResult DeleteSelected(string strIds)
{
InvokeResult result = new InvokeResult {
Success = true
};
try
{
List <IBatisNetBatchStatement> statements = new List <IBatisNetBatchStatement>();
string[] arrIds = strIds.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (arrIds.Length == 0)
{
result.Success = false;
result.ErrorCode = 59996;
return(result);
}
string statementName = new AssessmentResult().GetDeleteMethodName();
foreach (string strId in arrIds)
{
AssessmentResultPK pk = new AssessmentResultPK {
Id = Int32.Parse(strId)
};
DeleteCascade(statements, pk);
statements.Add(new IBatisNetBatchStatement {
StatementName = statementName, ParameterObject = pk, Type = SqlExecuteType.DELETE
});
}
BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(statements);
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.Message;
}
return(result);
}
public ActionResult Result(AssessmentViewModel assessmentViewModel, FormCollection objf)//(int empId, AssessmentViewModel assessmentViewModel)
{
AssessmentResultViewModel assessmentResultViewModel = new AssessmentResultViewModel();
//assessmentResultViewModel.AssessmentPaperId = assessmentViewModel.AssessmentPaper.AssessmentPaperId;
assessmentResultViewModel.AssessmentPaperId = Convert.ToInt32(objf["AssessmentViewModel.AssessmentQuestions[1].AssessmentPaperId"]);
assessmentResultViewModel.AssessmentPaperId = Convert.ToInt32(objf["HfldAssessmentPaperId"]);
assessmentResultViewModel.AssessmentDate = DateTime.Now;
assessmentResultViewModel.EmployeeId = Convert.ToInt32(Session["EmpID"]);
AssessmentResult assessmentResult = ConvertAssessmentResultViewModelToDomain(assessmentResultViewModel);
DataTable dtResultDetails;
dtResultDetails = new DataTable("AssessmentResultDetails");
dtResultDetails.Columns.Add("AssessmentResultId", typeof(int));
dtResultDetails.Columns.Add("QuestionId", typeof(int));
dtResultDetails.Columns.Add("SelectedAnswer", typeof(string));
dtResultDetails.Columns.Add("AnswerScore", typeof(int));
dtResultDetails.Columns.Add("isactive", typeof(bool));
dtResultDetails.Columns.Add("CreatedBy", typeof(int));
dtResultDetails.Columns.Add("CreatedOn", typeof(DateTime));
dtResultDetails.Columns.Add("LastEditedBy", typeof(int));
dtResultDetails.Columns.Add("LastEditedOn", typeof(DateTime));
//AssessmentViewModel
assessmentViewModel = GetAssessmentPaperById(assessmentResultViewModel.AssessmentPaperId);
if (assessmentViewModel.AssessmentQuestions != null && assessmentViewModel.AssessmentQuestions.Count > 0)
{
foreach (var question in assessmentViewModel.AssessmentQuestions)
{
string selectedAnswer = string.Empty;
if (question.IsMultiChoiceAnswer)
{
if (Convert.ToString(objf["Chk_AssessmentViewModel.AssessmentQuestions[" + question.QuestionId + "].Option1"]).Contains("true"))
{
selectedAnswer = selectedAnswer + " Option 1 ,";
}
if (Convert.ToString(objf["Chk_AssessmentViewModel.AssessmentQuestions[" + question.QuestionId + "].Option2"]).Contains("true"))
{
selectedAnswer = selectedAnswer + " Option 2 ,";
}
if (!string.IsNullOrEmpty(question.Option3Description))
{
if (Convert.ToString(objf["Chk_AssessmentViewModel.AssessmentQuestions[" + question.QuestionId + "].Option3"]).Contains("true"))
{
selectedAnswer = selectedAnswer + " Option 3 ,";
}
}
if (!string.IsNullOrEmpty(question.Option4Description))
{
if (Convert.ToString(objf["Chk_AssessmentViewModel.AssessmentQuestions[" + question.QuestionId + "].Option4"]).Contains("true"))
{
selectedAnswer = selectedAnswer + " Option 4 ,";
}
}
if (!string.IsNullOrEmpty(question.Option5Description))
{
if (Convert.ToString(objf["Chk_AssessmentViewModel.AssessmentQuestions[" + question.QuestionId + "].Option5"]).Contains("true"))
{
selectedAnswer = selectedAnswer + " Option 5 ,";
}
}
if (!string.IsNullOrEmpty(question.Option6Description))
{
if (Convert.ToString(objf["Chk_AssessmentViewModel.AssessmentQuestions[" + question.QuestionId + "].Option6"]).Contains("true"))
{
selectedAnswer = selectedAnswer + " Option 6 ,";
}
}
}
else
{
try
{
if (!string.IsNullOrEmpty(objf["Rbtn_AssessmentViewModel.AssessmentQuestions[" + question.QuestionId + "].Option"]))
{
selectedAnswer = objf["Rbtn_AssessmentViewModel.AssessmentQuestions[" + question.QuestionId + "].Option"];
}
}
catch (Exception)
{ }
}
selectedAnswer = selectedAnswer.TrimEnd(',');
if (selectedAnswer != "")
{
question.SelectedAnswer = selectedAnswer;
int score = 0;
score = CalculateScore(assessmentViewModel.AssessmentPaper.AssessmentPaperId, question.QuestionId, selectedAnswer, assessmentViewModel);
dtResultDetails.Rows.Add(1, question.QuestionId, question.SelectedAnswer, score, true, 1, DateTime.Now, 1, DateTime.Now);
}
}
}
string strResult = _IAssessmentService.SaveAssessmentResult(dtResultDetails, assessmentResult);
string [] strSplited = strResult.Split(',');
assessmentResultViewModel.TotalScore = Convert.ToInt32(strSplited[0]);
assessmentResultViewModel.OutofScore = assessmentViewModel.AssessmentQuestions.Count;
assessmentResultViewModel.Message = Convert.ToString(strSplited[1]);
return(View("Result", assessmentResultViewModel));
}
/// <summary>
/// This function obtains a live connection, then calls
/// an assessment operation specified by <paramref name="assessmentFunc"/>
/// </summary>
/// <typeparam name="TResult">
/// SQL Assessment result item type.
/// </typeparam>
/// <param name="requestParams">
/// Request parameters passed from the host.
/// </param>
/// <param name="connectParams">
/// Connection parameters used to identify and access the target.
/// </param>
/// <param name="taskUri">
/// An URI identifying the request task to enable concurrent execution.
/// </param>
/// <param name="assessmentFunc">
/// A function performing assessment operation for given target.
/// </param>
/// <returns>
/// Returns <see cref="AssessmentResult{TResult}"/> for given target.
/// </returns>
internal async Task <AssessmentResult <TResult> > CallAssessmentEngine <TResult>(
AssessmentParams requestParams,
ConnectParams connectParams,
string taskUri,
Func <SqlObjectLocator, Task <List <TResult> > > assessmentFunc)
where TResult : AssessmentItemInfo
{
var result = new AssessmentResult <TResult>
{
ApiVersion = ApiVersion
};
await ConnectionService.Connect(connectParams);
var connection = await ConnectionService.Instance.GetOrOpenConnection(taskUri, ConnectionType.Query);
try
{
var serverInfo = ReliableConnectionHelper.GetServerVersion(connection);
var hostInfo = ReliableConnectionHelper.GetServerHostInfo(connection);
var server = new SqlObjectLocator
{
Connection = connection,
EngineEdition = GetEngineEdition(serverInfo.EngineEditionId),
Name = serverInfo.ServerName,
ServerName = serverInfo.ServerName,
Type = SqlObjectType.Server,
Urn = serverInfo.ServerName,
Version = Version.Parse(serverInfo.ServerVersion),
Platform = hostInfo.Platform
};
switch (requestParams.TargetType)
{
case SqlObjectType.Server:
Logger.Write(
TraceEventType.Verbose,
$"SQL Assessment: running an operation on a server, platform:{server.Platform}, edition:{server.EngineEdition.ToString()}, version:{server.Version}");
result.Items.AddRange(await assessmentFunc(server));
Logger.Write(
TraceEventType.Verbose,
$"SQL Assessment: finished an operation on a server, platform:{server.Platform}, edition:{server.EngineEdition.ToString()}, version:{server.Version}");
break;
case SqlObjectType.Database:
var db = GetDatabaseLocator(server, connection.Database);
Logger.Write(
TraceEventType.Verbose,
$"SQL Assessment: running an operation on a database, platform:{server.Platform}, edition:{server.EngineEdition.ToString()}, version:{server.Version}");
result.Items.AddRange(await assessmentFunc(db));
Logger.Write(
TraceEventType.Verbose,
$"SQL Assessment: finished an operation on a database, platform:{server.Platform}, edition:{server.EngineEdition.ToString()}, version:{server.Version}");
break;
}
result.Success = true;
}
finally
{
ActiveRequests.TryRemove(taskUri, out _);
ConnectionService.Disconnect(new DisconnectParams {
OwnerUri = taskUri, Type = null
});
}
return(result);
}
internal static AnswerParser Parse(Assessment assessment, PaperItem[] paperItems, SetParserResult setParserResult)
{
#region Set
AnswerParserResultType resultType = AnswerParserResultType.Valid;
AssessmentSet set = AssessmentSet.SetA;
if (assessment.SetBEnabled || assessment.SetCEnabled)
{
switch (setParserResult)
{
case SetParserResult.SetB:
if (assessment.SetBEnabled)
{
set = AssessmentSet.SetB;
}
else
{
resultType = AnswerParserResultType.DisabledSetShaded;
}
break;
case SetParserResult.SetC:
if (assessment.SetCEnabled)
{
set = AssessmentSet.SetC;
}
else
{
resultType = AnswerParserResultType.DisabledSetShaded;
}
break;
case SetParserResult.Unshaded:
resultType = AnswerParserResultType.SetUnshaded;
break;
case SetParserResult.Multishaded:
resultType = AnswerParserResultType.SetMultishaded;
break;
}
}
if (resultType != AnswerParserResultType.Valid)
{
return(new AnswerParser()
{
ParserResult = resultType
});
}
#endregion
#region Items
AssessmentItem[] answerKeys = assessment.GetItems(set);
if (answerKeys.Length != paperItems.Length)
{
return(new AnswerParser()
{
ParserResult = AnswerParserResultType.Undefined
});
}
PaperKeyResultType[] paperKeyResultTypes = new PaperKeyResultType[answerKeys.Length];
for (int i = 0; i < answerKeys.Length; i++)
{
paperKeyResultTypes[i] = PaperKeyResultType.Correct;
int ansNum = 0;
ansNum += paperItems[i].A ? 1 : 0;
ansNum += paperItems[i].B ? 1 : 0;
ansNum += paperItems[i].C ? 1 : 0;
ansNum += paperItems[i].D ? 1 : 0;
ansNum += paperItems[i].E ? 1 : 0;
if (ansNum == 0)
{
paperKeyResultTypes[i] = PaperKeyResultType.Unshaded;
}
else if (ansNum > 1)
{
paperKeyResultTypes[i] = PaperKeyResultType.Invalid;
}
else
{
switch (answerKeys[i].Key)
{
case Key.A:
paperKeyResultTypes[i] = paperItems[i].A ? PaperKeyResultType.Correct : PaperKeyResultType.Incorrect;
break;
case Key.B:
paperKeyResultTypes[i] = paperItems[i].B ? PaperKeyResultType.Correct : PaperKeyResultType.Incorrect;
break;
case Key.C:
paperKeyResultTypes[i] = paperItems[i].C ? PaperKeyResultType.Correct : PaperKeyResultType.Incorrect;
break;
case Key.D:
paperKeyResultTypes[i] = paperItems[i].D ? PaperKeyResultType.Correct : PaperKeyResultType.Incorrect;
break;
case Key.E:
paperKeyResultTypes[i] = paperItems[i].E ? PaperKeyResultType.Correct : PaperKeyResultType.Incorrect;
break;
}
}
}
#endregion
#region Overall
int correctItems = 0;
int incorrectItems = 0;
int invalidItems = 0;
int unshadedItems = 0;
int totalItems = 0;
int correctPoints = 0;
int incorrectPoints = 0;
int invalidPoints = 0;
int unshadedPoints = 0;
int totalPoints = 0;
for (int i = 0; i < paperKeyResultTypes.Length; i++)
{
switch (paperKeyResultTypes[i])
{
case PaperKeyResultType.Correct:
correctItems++;
correctPoints += answerKeys[i].Points;
break;
case PaperKeyResultType.Incorrect:
incorrectItems++;
incorrectPoints += answerKeys[i].Points;
break;
case PaperKeyResultType.Invalid:
invalidItems++;
invalidPoints += answerKeys[i].Points;
break;
case PaperKeyResultType.Unshaded:
unshadedItems++;
unshadedPoints += answerKeys[i].Points;
break;
}
totalItems++;
totalPoints += answerKeys[i].Points;
}
double percentage = 100 * ((double)correctPoints / totalPoints);
AssessmentResult assessmentResult = percentage >= assessment.PassingRate ? AssessmentResult.Passed : AssessmentResult.Failed;
return(new AnswerParser()
{
ParserResult = AnswerParserResultType.Valid,
AssessmentSet = set,
Answers = paperItems,
AnswerResults = paperKeyResultTypes,
AssessmentResult = assessmentResult,
CorrectItems = correctItems,
IncorrectItems = incorrectItems,
InvalidItems = invalidItems,
UnshadedItems = unshadedItems,
TotalItems = totalItems,
CorrectPoints = correctPoints,
IncorrectPoints = incorrectPoints,
InvalidPoints = invalidPoints,
UnshadedPoints = unshadedPoints,
TotalPoints = totalPoints,
Percentage = percentage
});
#endregion
}
public ModelInvokeResult <AssessmentResultPK> UpdateWorkSchedule(string strId, AssessmentResult assessmentResult)
{
ModelInvokeResult <AssessmentResultPK> result = new ModelInvokeResult <AssessmentResultPK> {
Success = true
};
try
{
List <IBatisNetBatchStatement> statements = new List <IBatisNetBatchStatement>();
if (strId == null || strId == "undefined")
{
result.Success = false;
result.ErrorCode = 59996;
return(result);
}
/***********************begin 自定义代码*******************/
assessmentResult.Id = Int32.Parse(strId);
assessmentResult.OperatedBy = NormalSession.UserId.ToGuid();
assessmentResult.OperatedOn = DateTime.Now;
assessmentResult.DataSource = GlobalManager.DIKey_00012_ManualEdit;
/***********************end 自定义代码*********************/
statements.Add(new IBatisNetBatchStatement {
StatementName = assessmentResult.GetUpdateMethodName(), ParameterObject = assessmentResult.ToStringObjectDictionary(false), Type = SqlExecuteType.UPDATE
});
/***********************begin 自定义代码*******************/
/***********************此处添加自定义代码*****************/
/***********************begin 修改已经制定的工作计划中的服务时间*********************/
BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(statements);
result.instance = new AssessmentResultPK {
Id = Int32.Parse(strId)
};
string sql = "update Pam_WorkPlan set PlanDate=SUBSTRING(CONVERT(varchar(100),PlanDate, 21),1,11)+'" + assessmentResult.WorkSchedule + "'"
+ " ,OperatedBy='" + NormalSession.UserId.ToGuid() + "',OperatedOn='" + DateTime.Now + "'"
+ " where PlanDate>GETDATE() and WorkItem='" + assessmentResult.WorkItem + "' and OldManId='" + assessmentResult.OldManId + "'";
BuilderFactory.DefaultBulder().ExecuteNativeSqlNoneQuery(sql);
/***********************end 修改已经制定的工作计划中的服务时间*********************/
/***********************begin 重新生成工作执行表*********************/
SPParam spParam = new { }.ToSPParam();
spParam["OldManId"] = assessmentResult.OldManId;
spParam["BatchFlag"] = 0;
BuilderFactory.DefaultBulder().ExecuteSPNoneQuery("SP_Pam_GenDailyWorkExcute", spParam);
/***********************end 重新生成工作执行表*********************/
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.Message;
}
return(result);
}
public string SaveAssessmentResult(DataTable dtResultDetails, AssessmentResult assessmentResult)
{
return(_IAssessmentRepository.SaveAssessmentResult(dtResultDetails, assessmentResult));
}
public int SaveAssessmentResult(DataTable dtResultDetails, AssessmentResult assessmentResult)
{
return(0);
}
