public IActionResult GetPersonForAgency(long id, [Required, NotNull] string agencySystemName)
{
var agency = IdentityRepository.GetAgency(agencySystemName);
if (agency == null)
{
ModelState.AddModelError(nameof(agencySystemName), $"{agencySystemName} was not found");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Debug.Assert(agency != null, nameof(agency) + " != null");
var personIdentity = new PersonIdentity(id);
if (!IdentityRepository
.GetPeopleWithIdentifiers(new[] { personIdentity }, agency.RootIdentifierNames(), UserProvider)
.TryGetValue(personIdentity, out var identifiers))
{
return(NotFound(id));
}
var personIdForAgency = IdentityRepository.GetPersonAgencyId(personIdentity, agency.Id);
return(Ok(new AgencyPersonDto(personIdForAgency, IdentifierDtoMarshaller.MarshallToDtos(identifiers))));
}
public void CanAddAStudySubject()
{
var person = createContext.Add(new PersonEntity()).Entity;
createContext.SaveChanges();
var personId = new PersonIdentity(person.Id);
var subjectIdentifier = Random.String();
var addedSubject = CreateStudySubjectRepository(updateContext).AddStudySubject(
new StudySubject(studyId, subjectIdentifier, personId));
updateContext.SaveChanges();
using (new AssertionScope())
{
addedSubject.Should().NotBeNull();
addedSubject.StudyId.Should().Be(studyId);
addedSubject.PersonId.Should().Be(personId);
addedSubject.SubjectIdentifier.Should().Be(subjectIdentifier);
}
var studySubjectEntity = readContext.Set <StudySubjectEntity>()
.Include(_ => _.Study)
.Include(_ => _.Person)
.SingleOrDefault(
_ => _.Study.Id == addedSubject.StudyId && _.Person.Id == addedSubject.PersonId);
using (new AssertionScope())
{
studySubjectEntity.Should().NotBeNull();
studySubjectEntity.SubjectIdentifier.Should().Be(subjectIdentifier);
studySubjectEntity.Study.Id.Should().Be(studyId.Id);
studySubjectEntity.Person.Id.Should().Be(personId.Id);
}
}
/// <summary>
/// 返回EasyChatTimeModel
/// </summary>
/// <param name="identity">身份</param>
/// <param name="nameCn">中文名</param>
/// <param name="email">邮箱</param>
/// <param name="mobile">电话</param>
/// <param name="personId">id</param>
/// <returns></returns>
public EasyChatTimeModel ReturnEasyChatTimeModel(PersonIdentity identity, string nameCn, string email, string mobile, Guid personId)
{
EasyChatTimeModel returnModel = new EasyChatTimeModel();
ContactIdentity contact = new ContactIdentity
{
PersonIdentity = identity.ToString(),
NameCn = nameCn,
Email = email,
Mobile = mobile
};
IEnumerable <EasyChatTimeEntity> easyChatTimes = null;
if (identity == PersonIdentity.学生)
{
easyChatTimes = repository.EasyChatTime.Where(e => e.IfStudentID == personId).Select(e => e);
}
else
{
easyChatTimes = repository.EasyChatTime.Where(e => e.IfParentID == personId).Select(e => e);
}
returnModel.ContactIdentity = contact;
returnModel.EasyChatTimes = easyChatTimes;
return(returnModel);
}
/// <summary>
/// 修改联系人
/// </summary>
/// <param name="contact">EasyChatTimeModel类型</param>
/// <param name="contactIdentity">联系人身份</param>
/// <param name="studentID"></param>
void EditContact(EasyChatTimeModel contact, string contactIdentity, Guid studentID)
{
PersonIdentity identity = (PersonIdentity)Enum.Parse(typeof(PersonIdentity), contactIdentity);
//联系人身份
string personIdentity = contactIdentity;
if (contact == null)
{
if (IsHaveContact(personIdentity, studentID)) //如果数据库中对应身份的联系人记录，则删掉
{
repository.RemoveStudentParent(identity, studentID);
}
}
else
{
if (IsHaveContact(personIdentity, studentID)) //如果数据库中有对应身份的联系人记录，则修改
{
EditParentAndChattime(contact, studentID);
}
else
{
AddParentAndChattime(contact, studentID); //如果数据库中没有对应身份的联系人记录，则添加
}
}
}
/// <summary>
/// Initializes a new instance of the StudySubject class.
/// </summary>
public StudySubject(string subjectIdentifier = default(string), StudyIdentity studyId = default(StudyIdentity), PersonIdentity personId = default(PersonIdentity))
{
SubjectIdentifier = subjectIdentifier;
StudyId = studyId;
PersonId = personId;
CustomInit();
}
/// <summary>
/// 编辑Parent及其EasyChatTime
/// </summary>
/// <param name="contact"></param>
/// <param name="studentID"></param>
void EditParentAndChattime(EasyChatTimeModel contact, Guid studentID)
{
PersonIdentity identity = (PersonIdentity)Enum.Parse(typeof(PersonIdentity), contact.ContactIdentity.PersonIdentity);
//根据联系人身份和学生ID找出数据库中的Parent记录
StudentParentEntity parent = repository.StudentParent
.FirstOrDefault(s => s.StudentID == studentID && s.PersonIdentity == identity);
//联系人信息修改
parent.NameCn = contact.ContactIdentity.NameCn;
parent.Mobile = contact.ContactIdentity.Mobile;
parent.Email = contact.ContactIdentity.Email;
parent.QQ = contact.ContactIdentity.QQ;
parent.Weixin = contact.ContactIdentity.Weixin;
//保存联系人信息
repository.SaveStudentParent(parent);
//清空联系人的联系时间
repository.EmptyContactEasyChatTimes(parent.ParentID);
//重新添加联系人的联系时间
if (contact.EasyChatTimes != null)
{
foreach (EasyChatTimeEntity item in contact.EasyChatTimes)
{
item.IfParentID = parent.ParentID;
repository.SaveEasyChatTime(item); //添加EasyChatTime信息
}
}
}
public void RemoveStudentParent(PersonIdentity personIdentity, Guid studentID)
{
StudentParentEntity originEntity = context.StudentParent
.FirstOrDefault(s => s.StudentID == studentID && s.PersonIdentity == personIdentity);
context.StudentParent.Remove(originEntity);
EmptyContactEasyChatTimes(originEntity.ParentID);
context.SaveChanges();
}
public void BringsBackCorrectIdentifiers()
{
var personIdentity = new PersonIdentity(personOne.Id);
var foundDetails = CreateRepository(readContext)
.GetPeopleWithIdentifiers(
new[] { personIdentity },
new[] { testIdentifierDefinition.SystemName },
null
);
foundDetails.Should().ContainKey(personIdentity)
.WhichValue.Should()
.OnlyContain(identifier => identifier.Definition == testIdentifierDefinition);
}
/// <summary>
/// 检查StudentParent表中是否有学生的特定联系人
/// </summary>
/// <param name="personIdentity">联系人身份</param>
/// <param name="studentID">学生ID</param>
/// <returns></returns>
bool IsHaveContact(string personIdentity, Guid studentID)
{
PersonIdentity identity = (PersonIdentity)Enum.Parse(typeof(PersonIdentity), personIdentity);
StudentParentEntity contact = repository.StudentParent.FirstOrDefault(s => s.StudentID == studentID && s.PersonIdentity == identity);
if (contact == null)
{
return(false);
}
else
{
return(true);
}
}
public void BringsBackNoIdentifiersWhenPersonHasNoIdentifiers()
{
var personIdentity = new PersonIdentity(personTwo.Id);
var foundDetails = CreateRepository(readContext)
.GetPeopleWithIdentifiers(
new[] { personIdentity },
new[] { testIdentifierDefinition.SystemName },
null
);
foundDetails.Should().ContainKey(personIdentity)
.WhichValue.Should().BeEmpty();
}
/// <summary>
/// Create approved SwapShift requests for a list of people.
/// </summary>
/// <param name="personNumbers">List of person numbers whose request is approved.</param>
/// <param name="queryDateSpan">QueryDateSpan string.</param>
/// <param name="statusName">Request statusName.</param>
/// <returns>XML request string.</returns>
private string CreateApprovedSwapShiftRequests(
List <string> personNumbers,
string queryDateSpan,
string statusName)
{
var telemetryProps = new Dictionary <string, string>()
{
{ "QueryDateSpan", queryDateSpan },
{ "KronosStatus", statusName },
};
this.telemetryClient.TrackTrace($"SwapShiftActivity - CreateApproveSwapShiftRequests starts: {DateTime.UtcNow.ToString("O", CultureInfo.InvariantCulture)}", telemetryProps);
List <PersonIdentity> personIdentities = new List <PersonIdentity>();
foreach (var personNumber in personNumbers)
{
PersonIdentity personIdentity = new PersonIdentity
{
PersonNumber = personNumber,
};
personIdentities.Add(personIdentity);
}
var rq = new Models.RequestEntities.SwapShift.GetAllApprovedRequests.GetAllApprovedRequest
{
Action = RetrieveWithDetails,
RequestMgmt = new Models.RequestEntities.Common.RequestMgmt
{
QueryDateSpan = $"{queryDateSpan}",
RequestFor = SwapShiftRequest,
StatusName = statusName,
Employees = new Employees
{
PersonIdentity = personIdentities,
},
},
};
var request = rq.XmlSerialize();
this.telemetryClient.TrackTrace($"SwapShiftActivity - CreateApproveSwapShiftRequests: {request.ToString(CultureInfo.InvariantCulture)}", telemetryProps);
this.telemetryClient.TrackTrace($"SwapShiftActivity - CreateApproveSwapShiftRequests ends: {DateTime.UtcNow.ToString("O", CultureInfo.InvariantCulture)}", telemetryProps);
return(request);
}
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);
}
public IActionResult AddPersonIdentityAction(int idPersoana, long cnp, string serie, int numar, string emitent, DateTime dataEmitere, DateTime dataExpirare)
{
var person = _persons.GetById(idPersoana);
var personIdentity = new PersonIdentity
{
CNP = cnp,
Serie = serie,
Numar = numar,
Emitent = emitent,
DataEmitere = dataEmitere,
DataExpirare = dataExpirare,
Persoana = person
};
_personIdentity.Add(personIdentity);
return(RedirectToAction("Detail", new { id = idPersoana }));
}
public string GetPersonAgencyId(PersonIdentity personId, AgencyIdentity agencyId)
{
var existing = context.Set <PersonAgencyId>()
.SingleOrDefault(_ => _.PersonId == personId.Id && _.AgencyId == agencyId.Id);
if (existing != null)
{
return(existing.SpecificId);
}
var id = Convert.ToBase64String(Guid.NewGuid().ToByteArray()).TrimEnd('=');
context.Set <PersonAgencyId>()
.Add(new PersonAgencyId {
PersonId = personId.Id, AgencyId = agencyId.Id, SpecificId = id
});
context.SaveChanges();
return(id);
}
/// <inheritdoc />
public StudySubject(StudyIdentity studyId, string subjectIdentifier, PersonIdentity personId)
{
SubjectIdentifier = subjectIdentifier;
StudyId = studyId ?? throw new ArgumentNullException(nameof(studyId));
PersonId = personId ?? throw new ArgumentNullException(nameof(personId));
}
/// <summary>
/// Function to select person by person identity.
/// </summary>
/// <param name="personsParty">PersonsParty information</param>
/// <param name="personIdentity">Person identity information</param>
/// <returns>Instance of PersonsParty</returns>
internal static PersonsParty SelectPersonByPersonIdentity(PersonsParty personsParty, PersonIdentity personIdentity)
{
AssignSelectedPerson(personsParty, RetrievePersonByPersonIdentity(personsParty.RetrievePersons(), personIdentity).FirstOrDefault(), null);
return personsParty;
}
/// <summary>
/// Function to retrieve persons by person identity.
/// </summary>
/// <param name="persons">List of persons</param>
/// <param name="personIdentity">Person identity information</param>
/// <returns>Persons information to query</returns>
private static IEnumerable<PersonBase> RetrievePersonByPersonIdentity(IEnumerable<PersonBase> persons, PersonIdentity personIdentity)
{
return persons.Where(p => p.PersonId.Equals(personIdentity.PersonId, StringComparison.OrdinalIgnoreCase));
}
public void Remove(PersonIdentity newPersonIdentity)
{
_context.Remove(newPersonIdentity);
_context.SaveChanges();
}
public void Add(PersonIdentity newPersonIdentity)
{
_context.Add(newPersonIdentity);
_context.SaveChanges();
}
/// <inheritdoc />
public void UpdatePerson(
PersonIdentity personIdentity, IEnumerable <PersonIdentifier> identifiers, Authority authority)
{
Update(People.Find(personIdentity.Id), identifiers, authority);
}
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));
}
/// <summary>
/// 返回EasyChatTimeModel
/// </summary>
/// <param name="identity">身份</param>
/// <param name="nameCn">中文名</param>
/// <param name="email">邮箱</param>
/// <param name="mobile">电话</param>
/// <param name="personId">id</param>
/// <returns></returns>
public EasyChatTimeModel ReturnEasyChatTimeModel(PersonIdentity identity, string nameCn, string email, string mobile, Guid personId)
{
EasyChatTimeModel returnModel = new EasyChatTimeModel();
ContactIdentity contact = new ContactIdentity
{
PersonIdentity = identity.ToString(),
NameCn = nameCn,
Email = email,
Mobile = mobile
};
IEnumerable<EasyChatTimeEntity> easyChatTimes = null;
if (identity == PersonIdentity.学生)
easyChatTimes = repository.EasyChatTime.Where(e => e.IfStudentID == personId).Select(e => e);
else
easyChatTimes = repository.EasyChatTime.Where(e => e.IfParentID == personId).Select(e => e);
returnModel.ContactIdentity = contact;
returnModel.EasyChatTimes = easyChatTimes;
return returnModel;
}
StudySubject IStudySubjectRepository.FindStudySubject(StudyIdentity study, PersonIdentity personId)
{
return(GetStudySubject(FindStudySubjectForPerson(study, personId)));
}
public void RemoveStudentParent(PersonIdentity personIdentity, Guid studentID)
{
StudentParentEntity originEntity = context.StudentParent
.FirstOrDefault(s => s.StudentID == studentID && s.PersonIdentity == personIdentity);
context.StudentParent.Remove(originEntity);
EmptyContactEasyChatTimes(originEntity.ParentID);
context.SaveChanges();
}
/// <inheritdoc />
public ConsentRepositoryTests(ITestOutputHelper outputHelper, DatabaseFixture fixture) : base(outputHelper, fixture)
{
readContext = CreateNewContextInSameTransaction();
updateContext = CreateNewContextInSameTransaction();
createContext = CreateNewContextInSameTransaction();
study = createContext.Studies.Add(new StudyEntity {
Name = Random.String()
}).Entity;
var consentedPerson = createContext.People.Add(new PersonEntity()).Entity;
consentedStudySubject = createContext.Add(new StudySubjectEntity {
Study = study, Person = consentedPerson, SubjectIdentifier = "Consented"
}).Entity;
createContext.Add(
new ConsentEntity
{
StudySubject = consentedStudySubject,
DateProvided = 1.December(1965),
DateWithdrawn = 1.January(1966),
GivenBy = consentedPerson
});
activeConsent = createContext.Add(
new ConsentEntity
{
StudySubject = consentedStudySubject,
DateProvided = 1.February(1966),
GivenBy = consentedPerson
}).Entity;
var unconsentedPerson = createContext.People.Add(new PersonEntity()).Entity;
createContext.Add(
new StudySubjectEntity {
Study = study, Person = unconsentedPerson, SubjectIdentifier = "Unconsented"
});
var withdrawnConsent = createContext.Add(new PersonEntity()).Entity;
var withdrawnSubject = createContext.Add(
new StudySubjectEntity {
Study = study, Person = withdrawnConsent, SubjectIdentifier = "Withdrawn"
}).Entity;
withdrawnSubjectWithdrawnDate = 5.January(2018);
createContext.Add(new ConsentEntity
{
StudySubject = withdrawnSubject,
DateProvided = 1.December(2017),
DateWithdrawn = withdrawnSubjectWithdrawnDate,
GivenBy = withdrawnConsent
});
createContext.SaveChanges();
studyId = new StudyIdentity(study.Id);
consentedPersonId = consentedPerson;
unconsentedPersonId = unconsentedPerson;
withdrawnPersonId = withdrawnConsent;
consents = CreateConsentRepository(readContext);
studySubjects = CreateStudySubjectRepository(readContext);
studies = CreateStudyRepository(readContext);
}
