public ActionResult Edit(StudySubjectViewModel model)
{
var identity = (ClaimsIdentity)User.Identity;
var idString = identity.Claims.Where(c => c.Type == ClaimTypes.NameIdentifier)
.Select(c => c.Value).SingleOrDefault();
Guid UserId;
if (Guid.TryParse(idString, out UserId))
{
using (JournalContext db = new JournalContext())
{
User user = db.Users.Find(UserId);
var pupilRole = Guid.Parse(Roles.Pupil);
model.Users = db.Users.Where(c => c.UserRollID == pupilRole && c.SchoolID == user.SchoolID).Select(c => new SelectListItem()
{
Value = c.ID.ToString(), Text = c.FirstName + " " + c.LastName
}).ToList();
model.Subjects = db.Subjects.Where(c => c.Teacher.SchoolID == user.SchoolID).Select(c => new SelectListItem()
{
Value = c.ID.ToString(), Text = c.SubjectType.Name
}).ToList();
if (ModelState.IsValid)
{
StudySubject studySubject = db.StudySubject.Find(model.ID);
studySubject.UserID = Guid.Parse(model.SelectedUser);
studySubject.SubjectID = Guid.Parse(model.SelectedSubject);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
}
return(RedirectToAction("Login"));
}
public static void Save(StudySubject subject)
{
using (var db = new DBContext())
{
db.StudySubject.Add(subject);
db.SaveChanges();
}
}
private IStudySubjectRepository CreateSubjectRepository(Study study, StudySubject subject)
{
var fake = A.Fake <IStudySubjectRepository>(x => x.Strict());
A.CallTo(() => fake.GetStudySubject(study.Id, subject.SubjectIdentifier)).Returns(subject);
A.CallTo(() => fake.FindStudySubject(study.Id, subject.PersonId)).Returns(subject);
return(fake);
}
private IConsentRepository CreateConsentRepository(Study study, StudySubject studySubject)
{
var consentRepository = A.Fake <IConsentRepository>(x => x.Strict());
A.CallTo(() => consentRepository.AddConsent(A <Consent> ._))
.Invokes((Consent c) => CreatedConsent = c);
return(consentRepository);
}
private static void AssertStudySubject(StudySubjectEntity expected, StudySubject actual)
{
using (new AssertionScope())
{
actual.StudyId.Id.Should().Be(expected.Study.Id);
actual.PersonId.Id.Should().Be(expected.Person.Id);
actual.SubjectIdentifier.Should().Be(expected.SubjectIdentifier);
}
}
/// <inheritdoc />
public ConsentControllerTestBase()
{
Study = Create.Study;
StudyId = new StudyIdentity(Study.Id);
StudySubject = new StudySubject(StudyId, "AA100023", new PersonIdentity(500L));
Studies = CreateStudyRepository(Study);
StudySubjects = CreateSubjectRepository(Study, StudySubject);
Consents = CreateConsentRepository(Study, StudySubject);
}
public ActionResult Delete(StudySubjectViewModel model)
{
using (JournalContext db = new JournalContext())
{
StudySubject studySubject = db.StudySubject.Find(model.ID);
db.StudySubject.Remove(studySubject);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
/// <inheritdoc />
public WhenRecordingConsent_ForANewStudySubject()
{
newSubjectIdentifier = StudySubject.SubjectIdentifier + "New";
newPersonId = StudySubject.PersonId.Id + 1;
A.CallTo(() => StudySubjects.GetStudySubject(StudyId, newSubjectIdentifier)).Returns(null);
A.CallTo(() => StudySubjects.FindStudySubject(StudyId, new PersonIdentity(newPersonId))).Returns(null);
A.CallTo(() => StudySubjects.AddStudySubject(A <StudySubject> ._))
.Invokes((StudySubject created) => createdStudySubject = created);
RecordConsent(Evidences.ServerMedwayDto(takenBy: "Michael Fish"), A.Dummy <DateTime>(), subjectIdentifier: newSubjectIdentifier, personId: newPersonId);
}
// GET: StudySubject/Details/5
public ActionResult Details(Guid id)
{
using (JournalContext db = new JournalContext())
{
StudySubject studySubject = db.StudySubject.Find(id);
StudySubjectViewModel model = new StudySubjectViewModel();
model.UserID = studySubject.UserID;
model.SelectedUser = db.Users.Where(c => c.ID == model.UserID).Select(c => c.FirstName + " " + c.LastName).FirstOrDefault();
model.SubjectID = studySubject.SubjectID;
model.SelectedSubject = db.Subjects.Where(c => c.ID == model.SubjectID).Include(c => c.SubjectType).Select(c => c.SubjectType.Name).FirstOrDefault();
return(View(model));
}
}
public ConsentIdentity FindActiveConsent(StudySubject studySubject)
{
var consents =
Consents.Where(
_ => _.StudySubject.Person.Id == studySubject.PersonId.Id &&
_.StudySubject.Study.Id == studySubject.StudyId.Id &&
_.StudySubject.SubjectIdentifier == studySubject.SubjectIdentifier &&
_.DateWithdrawn == null);
var consentId = consents.Select(_ => (long?)_.Id).SingleOrDefault();
return(consentId == null ? null : new ConsentIdentity(consentId.Value));
}
public ActionResult Create(StudySubjectViewModel model)
{
using (JournalContext db = new JournalContext())
{
if (ModelState.IsValid)
{
StudySubject studySubject = (StudySubject)model;
studySubject.ID = Guid.NewGuid();
db.StudySubject.Add(studySubject);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
return(View(model));
}
CreateStudySubject(string subjectIdentifier)
{
var person = createContext.Add(new PersonEntity()).Entity;
var studySubjectEntity = createContext.Add(
new StudySubjectEntity
{
Person = person,
Study = createContext.Find <StudyEntity>(study.Id),
SubjectIdentifier = subjectIdentifier
}).Entity;
createContext.SaveChanges();
var personId = new PersonIdentity(person.Id);
var studySubject = new StudySubject(studyId, subjectIdentifier, personId);
return(personId, studySubjectEntity, studySubject);
}
/// <inheritdoc />
public void WithdrawConsent(StudySubject studySubject, params Evidence[] allEvidence)
{
var activeConsent = ConsentsFor(studySubject.StudyId.Id, studySubject.SubjectIdentifier)
.Where(_ => _.DateWithdrawn == null)
.OrderByDescending(_ => _.DateProvided)
.FirstOrDefault();
activeConsent.DateWithdrawn = DateTime.Now;
foreach (var evidence in allEvidence)
{
activeConsent.WithdrawnEvidence.Add(
new WithdrawnEvidenceEntity
{
Type = evidence.Definition.SystemName,
Value = EvidenceRegistry.MarshallToXml(evidence).ToString(SaveOptions.DisableFormatting),
}
);
}
}
public static StudySubjectModel ToModel(this StudySubject subject)
{
if (subject == null)
{
return(null);
}
var model = new StudySubjectModel()
{
Name = subject.Name,
Marks = new List <MarkModel>(),
};
if (subject.Mark != null)
{
model.Marks = subject.Mark.Select(m => m.ToModel()).ToList();
}
return(model);
}
public static StudySubject ToData(this StudySubjectModel subject)
{
if (subject == null)
{
return(null);
}
var data = new StudySubject()
{
Name = subject.Name,
Mark = new List <Mark>(),
};
if (subject.Marks != null)
{
data.Mark = subject.Marks.Select(m => m.ToData()).ToList();
}
return(data);
}
public ActionResult Edit(Guid?id)
{
if (id == null)
{
return(HttpNotFound());
}
var identity = (ClaimsIdentity)User.Identity;
var idString = identity.Claims.Where(c => c.Type == ClaimTypes.NameIdentifier)
.Select(c => c.Value).SingleOrDefault();
Guid UserId;
if (Guid.TryParse(idString, out UserId))
{
using (JournalContext db = new JournalContext())
{
User user = db.Users.Find(UserId);
StudySubjectViewModel model = new StudySubjectViewModel();
StudySubject studySubject = db.StudySubject.Find(id);
var pupilRole = Guid.Parse(Roles.Pupil);
model.ID = studySubject.ID;
model.SubjectID = studySubject.SubjectID;
model.UserID = studySubject.UserID;
model.Users = db.Users.Where(c => c.UserRollID == pupilRole && c.SchoolID == user.SchoolID).Select(c => new SelectListItem()
{
Value = c.ID.ToString(), Text = c.FirstName + " " + c.LastName
}).ToList();
model.Subjects = db.Subjects.Where(c => c.Teacher.SchoolID == user.SchoolID).Select(c => new SelectListItem()
{
Value = c.ID.ToString(), Text = c.SubjectType.Name
}).ToList();
model.SelectedUser = db.Users.Where(c => c.ID == model.UserID).Select(c => c.FirstName + " " + c.LastName).FirstOrDefault();
model.SelectedSubject = db.Subjects.Where(c => c.ID == model.SubjectID).Include(c => c.SubjectType).Select(c => c.SubjectType.Name).FirstOrDefault();
return(View(model));
}
}
return(RedirectToAction("Login"));
}
private Task <AgencyPersonDto> GetDetailsForPerson(StudySubject studySubject)
{
Logger.LogDebug("Getting details for {@Person}", studySubject.PersonId);
return(ApiClient.GetPersonForAgencyAsync(AgencyName, studySubject.PersonId.Id));
}
public IActionResult PutConsent([FromBody] ConsentSpecification specification)
{
if (!ModelState.IsValid)
{
Logger.LogInformation("Invalid ModelState {@error}", new SerializableError(ModelState));
return(new BadRequestObjectResult(ModelState));
}
var study = Studies.GetStudy(specification.StudyId);
if (study == null)
{
Logger.LogWarning("Study#{studyId} not found", specification.StudyId);
return(NotFound());
}
var studySubject = Subjects.GetStudySubject(study.Id, specification.SubjectIdentifier);
if (studySubject == null)
{
var subjectSpecification = new { specification.StudyId, specification.PersonId };
Logger.LogDebug("No existing studySubject - creating a new subject for {spec}", subjectSpecification);
var personId = new PersonIdentity(specification.PersonId);
studySubject = Subjects.FindStudySubject(study.Id, personId);
if (studySubject != null)
{
Logger.LogError("There is already a study subject for {spec} - {identifier}", subjectSpecification, studySubject.SubjectIdentifier);
return(BadRequest());
}
studySubject = new StudySubject(study.Id, specification.SubjectIdentifier, personId);
studySubject = Subjects.AddStudySubject(studySubject);
}
else
{
var existingConsent = Consents.FindActiveConsent(studySubject);
if (existingConsent != null)
{
//TODO: Decide what to do with evidence, etc, for existing consents, or if you can be consented twice
return(new SeeOtherOjectActionResult(
"GetStudySubject",
routeValues: new { studyId = study, subjectIdentifier = studySubject.SubjectIdentifier },
result: existingConsent.Id));
}
}
var evidence = EvidenceDtoMarshallers.ConvertToIdentifiers(specification.Evidence);
var newConsentId = Consents.AddConsent(
new Common.Consent.Consent(
studySubject,
specification.DateGiven,
specification.GivenBy,
evidence));
return(CreatedAtAction(
"GetStudySubject",
new { studyId = study, subjectIdentifier = studySubject.SubjectIdentifier },
newConsentId.Id));
}
public void Deconstruct(out StudySubject subject, out IEnumerable <PersonIdentifier> identifiers)
{
subject = Subject;
identifiers = Identifiers;
}
private async Task <IList <IIdentifierValueDto> > GetIdentifiers(StudySubject studySubject)
{
return(fieldNames.Any()
? await ApiClient.GetPersonAsync(studySubject.PersonId.Id.Value)
: Array.Empty <IIdentifierValueDto>());
}
