private static void AssignPointsAndPosition(int weekNumber, Result x, TestResultDto result)
{
switch (weekNumber)
{
case 1:
result.Position = x.Week1Place ?? 0;
result.Points = x.Week1Points ?? 0;
break;
case 2:
result.Position = x.Week2Place ?? 0;
result.Points = x.Week2Points ?? 0;
break;
case 3:
result.Position = x.Week3Place ?? 0;
result.Points = x.Week3Points ?? 0;
break;
case 4:
result.Position = x.FinalPlace ?? 0;
result.Points = x.FinalPoints ?? 0;
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="attribute"></param>
/// <returns></returns>
///
public TestResultDto DeleteAttribute(TestResultDto attribute)
{
PatientTestResultHelper visitHelper = new PatientTestResultHelper();
MapperConfig.ConfigAutoMapper();
if (attribute != null)
{
attribute.ModifiedDate = DateTime.Now;
attribute.CreatedDate = new DateTime(2017, 7, 6);
attribute.CreatedBy = "EMP01";
attribute.ModifiedBy = null;
IList <TestResultDto> TestRes = visitHelper.GetTestResults(attribute.VisitID);
TestResult Del = context.TestResults.SingleOrDefault(item => item.ID == attribute.ID);
context.TestResults.Remove(Mapper.Map <TestResult>(Del));
context.SaveChanges();
return(null);
}
else
{
throw new NullReferenceException("null attrib");
}
}
/// <summary>
///
/// </summary>
/// <param name="updateAttribute"></param>
/// <param name="user"></param>
/// <returns></returns>
public TestTemplateAttributeDto UpdateAttribute(TestResultDto updateAttribute, UserDto user)
{
MapperConfig.ConfigAutoMapper();
if ((updateAttribute != null) && (user != null))
{
PatientTestResultHelper Resulthelp = new PatientTestResultHelper();
// Attribute set according to the visit ID
IList <TestResultDto> ResultAttributes = Resulthelp.GetTestResults(updateAttribute.VisitID);
//updateAttribute.AttrID = Resulthelp.GetResultByVisitID(updateAttribute.VisitID).AttrID;
updateAttribute.ModifiedDate = DateTime.Now;
updateAttribute.VisitID = Resulthelp.GetResultByID(updateAttribute.ID).VisitID;
updateAttribute.AttrID = Resulthelp.GetResultByID(updateAttribute.ID).AttrID;
updateAttribute.CreatedBy = Resulthelp.GetResultByVisitID(updateAttribute.VisitID).CreatedBy;
updateAttribute.CreatedDate = Resulthelp.GetResultByVisitID(updateAttribute.VisitID).CreatedDate;
updateAttribute.ModifiedBy = user.Username;
ResultRepo.Update(Mapper.Map <TestResult>(updateAttribute));
}
else
{
System.Diagnostics.Debug.WriteLine("Null Attribute ! / Null User ");
}
return(null);
}
public IHttpActionResult UpdateTestStatus([FromBody] TestResultDto testResult)
{
var taskInfo = _taskSvc.UpdateTestStatus(testResult);
_taskSvc.NotifyTestResult(testResult);
return(Ok());
}
public string SaveChildProgress(TestResultDto result)
{
BLL.LearnHebrewEntities.Child child = new BLL.LearnHebrewEntities.Child();
try
{
child = Auxiliray.Session.ChildInSession;
if (child == null)// the user is not found
{
return("failed to find child");
}
var childProgress = BLL.Services.ChildProgressServices.LoadSpecificChildProgressesByChildID(result.ProgressID);
childProgress.Data.Letter = result.GameLetter;
childProgress.Data.EndDate = DateTime.Now;
if (result.WrongAnswers != null)
{
for (var i = 0; i < result.WrongAnswers.Length; i++)
{
childProgress.Data.WrongAnswers.Add(result.CorresponsingContentID[i], result.WrongAnswers[i]);
}
}
var savingProgress = BLL.Services.ChildProgressServices.Save(childProgress);
}
catch (Exception ex)
{
return("fail");
}
return("OK");
}
public void Printreport()
{
TestResultDto result = new TestResultDto()
{
VisitID = 75
};
ReportGenerateManagement reportmngr = new ReportGenerateManagement();
var Generate = reportmngr.PrintReport(result);
}
public void DeleteResultRow()
{
TestResultDto Attribute = new TestResultDto()
{
ID = 334,
VisitID = 73,
};
TestResultManager Attrib = new TestResultManager();
var res = Attrib.DeleteAttribute(Attribute);
}
public void PrintSlip()
{
TestResultDto res = new TestResultDto()
{
VisitID = 76,
};
decimal payment = 5000;
bool discount = true;
double discountAmount = 0.2;
PaymentManagement paymentmanager = new PaymentManagement();
var pay = paymentmanager.CreateSlip(res, payment, discount, discountAmount);
}
private List <bool> VisibilityList(TestResultDto dto)
{
var counter = new int[10];
foreach (SampleResultSetDto item in dto.SampleResultSets)
{
if (!string.IsNullOrEmpty(item.Value1))
{
counter[0]++;
}
if (!string.IsNullOrEmpty(item.Value2))
{
counter[1]++;
}
if (!string.IsNullOrEmpty(item.Value3))
{
counter[2]++;
}
if (!string.IsNullOrEmpty(item.Value4))
{
counter[3]++;
}
if (!string.IsNullOrEmpty(item.Value5))
{
counter[4]++;
}
if (!string.IsNullOrEmpty(item.Value6))
{
counter[5]++;
}
if (!string.IsNullOrEmpty(item.Value7))
{
counter[6]++;
}
if (!string.IsNullOrEmpty(item.Value8))
{
counter[7]++;
}
if (!string.IsNullOrEmpty(item.Value9))
{
counter[8]++;
}
if (!string.IsNullOrEmpty(item.Value10))
{
counter[9]++;
}
}
return(counter.Select(x => x > 0).ToList());
}
public async Task <int> AddTestResult(TestResultDto testResultData)
{
try
{
var TestResult = _mapper.Map <TestResult>(testResultData);
_dbContext.TestResults.Add(TestResult);
await _dbContext.SaveChangesAsync();
return(TestResult.Id);
}
catch (Exception)
{
return(-1);
}
}
public void AddTestResult(TestResultDto TestResultDtoObj)
{
FreeLancer FLancObj = db.FreeLance.FirstOrDefault(f => f.ID == TestResultDtoObj.FreeLancerObjId);
test tObj = db.test.FirstOrDefault(t => t.id == TestResultDtoObj.testObjId);
test_result TestResultObj = new test_result()
{
Test_time = DateTime.Now,
test_Name = TestResultDtoObj.test_Name,
score = TestResultDtoObj.score,
FreeLancerObj = FLancObj,
testObj = tObj
};
db.test_result.Add(TestResultObj);
db.SaveChanges();
}
public async Task <int> PostTestResult(User user, Test test, TestResultDto testResult)
{
using (var client = new HttpClient())
{
InitializeClient(client);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("api/test"));
HttpResponseMessage response = await client
.PostAsJsonAsync($"api/test/result/{user.ID}/{test.ID}", testResult);
response.EnsureSuccessStatusCode();
var serializer = new DataContractJsonSerializer(typeof(int));
return((int)serializer.ReadObject(await response.Content.ReadAsStreamAsync()));
}
}
/// <summary>
/// /
/// </summary>
/// <param name="res"></param>
/// <param name="price"></param>
/// <param name="payment"></param>
/// <param name="discount"></param>
/// <param name="balance"></param>
/// <param name="FinalAmount"></param>
/// <returns></returns>
///
public TestResultDto PirntSlip(TestResultDto res, Decimal price, decimal payment, decimal discount, decimal balance, decimal FinalAmount)
{
string path = Environment.GetFolderPath(Environment.SpecialFolder.CommonDocuments);
string fileName = "" + path + "\\paymentSlip.docx";
var doc = DocX.Create(fileName);
decimal dis = price * discount;
doc.InsertParagraph(" _________________________________________________________________________");
doc.InsertParagraph(" ");
doc.InsertParagraph(" LAB REPORT MANAGEMENT SYSTEM | FINAL PAYEMENT DETAIL ");
doc.InsertParagraph(" _________________________________________________________________________");
doc.InsertParagraph(" ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" Visit ID : " + res.VisitID + " ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" Test Price Rs : " + price + " Payment Rs : " + payment + " ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" Discount Rs : " + dis + " ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" _________________________________________________________________________");
doc.InsertParagraph(" ");
doc.InsertParagraph(" Final Amount Rs : " + FinalAmount + " ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" Balance Rs Rs : " + balance + " ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" _________________________________________________________________________");
doc.InsertParagraph(" ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" ");
doc.Save();
/*Open as html format*/
SautinSoft.RtfToHtml z = new SautinSoft.RtfToHtml();
string docxFile = Path.GetFullPath(fileName);
string htmlFile = Path.ChangeExtension(docxFile, ".html");
z.OpenDocx(docxFile);
z.ToHtml(htmlFile);
System.Diagnostics.Process.Start(htmlFile);
return(null);
}
public async Task <TestResultDto> GetTestResultAsync(string userId, int testId)
{
var testResult = await Database.TestResultRepository.GeTestResultAsync(userId, testId);
var result = await CalculateResult(testId);
var testResultDto = new TestResultDto
{
Id = testResult.Id,
TestId = testResult.TestId,
UserId = testResult.UserId,
SummaryResult = testResult.SummaryResult,
IsPassed = testResult.SummaryResult > result
};
return(testResultDto);
}
/// <summary>
///
/// </summary>
/// <param name="res"></param>
/// <param name="payment"></param>
/// <param name="discount"></param>
/// <param name="dis"></param>
/// <returns></returns>
///
public object CreateSlip(TestResultDto res, decimal payment, bool discount, double dis)
{
var Test = test.GetTest(res.VisitID);
Decimal price = Test.Price;
decimal Discount = (Decimal)dis;
if (payment > price)
{
if (discount.Equals(true))
{
decimal FinalAmount = price - (price * Discount);
decimal balance = payment - FinalAmount;
this.PirntSlip(res, price, payment, Discount, balance, FinalAmount);
}
else
{
decimal FinalAmount = price;
decimal balance = payment - FinalAmount;
this.PirntSlip(res, price, payment, 0, balance, FinalAmount);
}
}
if (payment == price)
{
if (discount.Equals(true))
{
decimal FinalAmount = price - (price * Discount);
decimal balance = payment - FinalAmount;
this.PirntSlip(res, price, payment, Discount, balance, FinalAmount);
}
else
{
decimal FinalAmount = price;
decimal balance = payment - FinalAmount;
this.PirntSlip(res, price, payment, 0, balance, FinalAmount);
}
}
else if (payment < price)
{
throw new InvalidOperationException("Invalid Payment amount insert ! ");
}
return(null);
}
public async Task <int> UpdateTestResult(TestResultDto testResultData)
{
try
{
var savedTestResult = _dbContext.TestResults.AsNoTracking().FirstOrDefault(p => p.Id == testResultData.Id);
if (savedTestResult == null)
{
return(-1);
}
_dbContext.Entry(_mapper.Map <TestResult>(testResultData)).State = EntityState.Modified;
await _dbContext.SaveChangesAsync();
return(savedTestResult.Id);
}
catch (Exception e)
{
return(-1);
}
}
public async Task SubmitTestAsync(CraftedTest craftedTest)
{
var numOfQuestions = craftedTest.TestBaseDto.NumOfQuestions;
var numOfCorrectAnswers = 0;
foreach (var questionDto in craftedTest.Questions)
{
var currentQuestionIsAnsweredCorrect = true;
foreach (var answerDto in questionDto.Answers)
{
var correctAnswer = await _unitOfWork.AnswerRepository.GetByIdAsync(answerDto.Id);
if (answerDto.IsCorrect != correctAnswer.IsCorrect)
{
currentQuestionIsAnsweredCorrect = false;
break;
}
}
if (currentQuestionIsAnsweredCorrect)
{
numOfCorrectAnswers++;
}
}
var score = (float)numOfCorrectAnswers / (float)numOfQuestions * 100;
score = (float)Math.Round(score, 2);
var testResultDto = new TestResultDto
{
Date = craftedTest.Date,
TestBaseId = craftedTest.TestBaseDto.Id,
StudentUserId = craftedTest.User.Id,
Score = score
};
var testResultEntity = TestResultMapper.Map(testResultDto);
await _unitOfWork.TestResultRepository.InsertAsync(testResultEntity);
await _unitOfWork.CommitAsync();
}
public void UpdateAttribute()
{
TestResultDto updateResult = new TestResultDto()
{
//Result ID
ID = 358,
Value = "1.5%",
Status = " Normal",
};
UserDto user = new UserDto()
{
UserId = 42,
Username = "******"
};
TestResultManager Attrib = new TestResultManager();
var res = Attrib.UpdateAttribute(updateResult, user);
}
public AssignmentResultDto ToAssignmentResultDto(AssignmentWithLastResultsOfUser assignmentWithLastResultsOfUser)
{
var resultDto = new AssignmentResultDto
{
AssignmentId = assignmentWithLastResultsOfUser.Assignment.Id,
TestResults = new List <TestResultDto>()
};
foreach (var testWithResults in assignmentWithLastResultsOfUser.TestsWithLastResultOfUser)
{
var testResultDto = new TestResultDto
{
TestId = testWithResults.Test.Id,
TestName = testWithResults.Test.TestName,
Passed = testWithResults.TestResult.Passed,
Message = testWithResults.TestResult.Message
};
resultDto.TestResults.Add(testResultDto);
}
return(resultDto);
}
public async Task <IActionResult> GetArchivedTestResults()
{
var allTests =
await _testRepository.
FindByIncludeAllAsync(t => t.IsArchived == true);
IList <TestResultDto> allTestResultDtos = new List <TestResultDto>();
foreach (var test in allTests)
{
var testDto = Mapper.Map <TestDto>(test);
if (test.IsFinished)
{
FillTestDto(test, testDto);
}
TestResultDto testResult = new TestResultDto
{
Id = testDto.Id,
Candidate = testDto.Candidate.FirstName + " " + testDto.Candidate.LastName,
Email = testDto.Candidate.Email,
JobApplied = testDto.Job.Title,
FinishedDate = testDto.FinishedDate,
Result = testDto.IsFinished ? testDto.IsTestPassed ? "Passed" : "Failed" : string.Empty,
College = testDto.Candidate.College,
CGPA = testDto.Candidate.CGPA,
TotalRightAnswers = testDto.TotalRightAnswers,
IsFinished = testDto.IsFinished
};
allTestResultDtos.Add(testResult);
}
return(Ok(allTestResultDtos));
}
/// <summary>
///
/// </summary>
/// <param name="printreport"></param>
/// <returns></returns>
public TestResultDto PrintReport(TestResultDto printreport)
{
MapperConfig.ConfigAutoMapper();
if (printreport != null)
{
int patientid = visit.GetVisit(printreport.VisitID).PatientID;
var patient = base.context.Patients.AsNoTracking().FirstOrDefault(p => p.PatientId.Equals(patientid));
String name = patient.Name;
int age = patient.Age;
string sex = patient.Gender;
string address = patient.Address;
string number = patient.ContactNo;
DateTime arrivedate = visit.GetVisit(printreport.VisitID).ArriveDate;
DateTime ExpDelDate = visit.GetVisit(printreport.VisitID).ExpectedDeliveryDate;
int TesTID = test.GetTest(printreport.VisitID).TemplateID;
var testTemplate = base.context.TestTemplates.FirstOrDefault(p => p.TestTemplateId.Equals(TesTID));
string templatename = testTemplate.TemplateName;
int temID = testTemplate.TestTemplateId;
decimal price = testTemplate.Price;
IList <TestResultDto> results = resultSet.GetTestResults(printreport.VisitID);
IList <TestTemplateAttributeDto> Attribs = VisitHelper.GetTestTemplateAttributes(temID);
string path = Environment.GetFolderPath(Environment.SpecialFolder.CommonDocuments);
string fileName = "" + path + "\\Report.docx";
var doc = DocX.Create(fileName);
doc.InsertParagraph(" __________________________________________________________________________________________________ ");
doc.InsertParagraph("");
doc.InsertParagraph(" MEDICAL LAB REPORT MANAGEMENT SYSTEM | FINAL TEST REPORT ");
doc.InsertParagraph("");
doc.InsertParagraph(" __________________________________________________________________________________________________ ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" Patient Name : " + name + " Gender : " + sex + " ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" Patient Age : " + age + " Address:" + address + " Payment : RS: " + price + "");
doc.InsertParagraph(" ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" Contact Number : " + number + " Test : " + templatename + " ");
doc.InsertParagraph(" ");
doc.InsertParagraph("");
doc.InsertParagraph(" Arrived Date: " + arrivedate + " Deliver Date:" + ExpDelDate + " ");
doc.InsertParagraph(" ");
doc.InsertParagraph(" __________________________________________________________________________________________________ ");
doc.InsertParagraph("");
doc.InsertParagraph(" Patients Results ");
doc.InsertParagraph("");
doc.InsertParagraph("");
int seq = 1;
foreach (var x in results)
{
doc.InsertParagraph(" " + seq + " Value: " + x.Value + " Status : " + x.Status + "");
doc.InsertParagraph("");
seq++;
if (seq > Attribs.Count)
{
break;
}
}
doc.InsertParagraph("");
doc.InsertParagraph("");
doc.InsertParagraph(" Reffer below Information. ");
doc.InsertParagraph("");
doc.InsertParagraph("");
int NextSeq = 1;
foreach (var x in Attribs)
{
doc.InsertParagraph(" " + NextSeq + " . " + x.Attribute + " --> " + x.PrefferedLimit + "");
doc.InsertParagraph("");
doc.InsertParagraph("");
NextSeq++;
}
doc.Save();
/*Open as html format*/
SautinSoft.RtfToHtml z = new SautinSoft.RtfToHtml();
string docxFile = Path.GetFullPath(fileName);
string htmlFile = Path.ChangeExtension(docxFile, ".html");
z.OpenDocx(docxFile);
z.ToHtml(htmlFile);
System.Diagnostics.Process.Start(htmlFile);
return(null);
}
else
{
throw new ArgumentNullException("Provided information is not valid.");
}
}
public async Task <IActionResult> AddTestResult([FromBody] TestResultDto testResult, int userId, int testId)
{
var user = await _testManager.AddTestResult(testResult, userId, testId);
return(Ok(user.Points));
}
public void UpdateTestResult(TestResultDto entity)
{
UpdateEntity <TestResult, TestResultDto>(entity);
}
public TestResultDto InsertTestResult(TestResultDto entity)
{
return(AddEntity <TestResult, TestResultDto>(entity));
}
private async void NextExercise()
{
var result = new ResultPresenter
{
Number = Results.Count + 1,
IsCorrect = false
};
if (((IExerciseView)_gridOfTest.Children[0]).CheckIsCorrect())
{
CorrectAnswers++;
result.IsCorrect = true;
}
Results.Add(result);
_gridOfTest.Children.Clear();
if (Test.CategoryName == "Nyelvtan")
{
if (GrammarExercises.Count != _currentExerciseNum)
{
IExerciseView exerciseView = new GrammarChooseOneExerciseView(
GrammarExercises[_currentExerciseNum], new RelayCommand(NextExercise)
);
_gridOfTest.Children.Add(exerciseView.GetUIElement());
_currentExerciseNum++;
}
else
{
Points = (int)(CorrectAnswers / (float)Test.NumberOfQuestions * Test.MaxPoints);
End = true;
var service = new TestService();
var testResult = new TestResultDto
{
RightAnswers = CorrectAnswers,
WrongAnswers = Test.NumberOfQuestions - CorrectAnswers,
Points = Points
};
var userPoints = await service.PostTestResult(LoggedInUser, Test, testResult);
LoggedInUser.Points = userPoints;
}
}
else
{
if (VocabularyExercises.Count != _currentExerciseNum)
{
var exercise = VocabularyExercises[_currentExerciseNum];
IExerciseView exerciseView = SetExerciseType(exercise);
_gridOfTest.Children.Add(exerciseView.GetUIElement());
_currentExerciseNum++;
}
else
{
Points = (int)(CorrectAnswers / (float)Test.NumberOfQuestions * Test.MaxPoints);
End = true;
var service = new TestService();
var testResult = new TestResultDto
{
RightAnswers = CorrectAnswers,
WrongAnswers = Test.NumberOfQuestions - CorrectAnswers,
Points = Points
};
var userPoints = await service.PostTestResult(LoggedInUser, Test, testResult);
LoggedInUser.Points = userPoints;
}
}
}
public TestResultDto InsertTestResult(TestResultDto entity)
{
return(new TestResultDto {
Rn = ++NextRn
});
}
public async Task <User> AddTestResult(TestResultDto testResult, int userId, int testId)
{
var dbTestResult = _mapper.Map <DbTestResult>(testResult);
return(_mapper.Map <User>(await _testRepository.AddTestResultAsync(dbTestResult, userId, testId)));
}
public void UpdateTestResult(TestResultDto entity)
{
}
