Esempio n. 1
0
        public UpdatePatientNoteDataResponse Put(UpdatePatientNoteDataRequest request)
        {
            UpdatePatientNoteDataResponse response = new UpdatePatientNoteDataResponse();

            try
            {
                RequireUserId(request);
                response.PatientNoteData = Manager.UpdatePatientNote(request);
            }
            catch (Exception ex)
            {
                RaiseException(response, ex);
            }
            return(response);
        }
Esempio n. 2
0
        public PatientNoteData UpdatePatientNote(UpdatePatientNoteDataRequest request)
        {
            PatientNoteData result = null;

            try
            {
                IMongoPatientNoteRepository repo = Factory.GetRepository(RepositoryType.PatientNote);
                if (request.PatientNoteData != null)
                {
                    bool status = (bool)repo.Update(request);
                    if (status)
                    {
                        result = (PatientNoteData)repo.FindByID(request.PatientNoteData.Id);
                    }
                }
                return(result);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Esempio n. 3
0
        public void UpdatePatientNote_Test()
        {
            List <string> prog = new List <string>();

            prog.Add("558c756184ac0707d02f72c8");

            PatientNoteData data = new PatientNoteData {
                Id                = "558c757284ac05114837dc38",
                PatientId         = "5429d29984ac050c788bd34f",
                Text              = "ABCABC",
                ProgramIds        = prog,
                TypeId            = "54909997d43323251c0a1dfe",
                MethodId          = "540f1da7d4332319883f3e8c",
                WhoId             = "540f1fc3d4332319883f3e97",
                OutcomeId         = "540f1f14d4332319883f3e93",
                SourceId          = "540f2091d4332319883f3e9c",
                Duration          = 10,
                ValidatedIdentity = false,
                ContactedOn       = DateTime.Now.AddDays(4)
            };

            UpdatePatientNoteDataRequest request = new UpdatePatientNoteDataRequest
            {
                Context         = context,
                ContractNumber  = contractNumber,
                UserId          = userId,
                Version         = version,
                PatientNoteData = data,
                Id        = data.Id,
                PatientId = data.PatientId
            };

            string requestURL = string.Format("{0}/{1}/{2}/{3}/Patient/{4}/Note/{5}", url, context, version, contractNumber, data.PatientId, data.Id);
            //[Route("/{Context}/{Version}/{ContractNumber}/Patient/{PatientId}/Note/{Id}", "PUT")]
            UpdatePatientNoteDataResponse response = client.Put <UpdatePatientNoteDataResponse>(requestURL, request);

            Assert.IsNotNull(response);
        }
 public PatientNoteData UpdatePatientNote(UpdatePatientNoteDataRequest request)
 {
     throw new NotImplementedException();
 }
        public object Update(object entity)
        {
            bool result = false;
            UpdatePatientNoteDataRequest request = (UpdatePatientNoteDataRequest)entity;
            PatientNoteData pn = request.PatientNoteData;

            try
            {
                using (PatientNoteMongoContext ctx = new PatientNoteMongoContext(ContractDBName))
                {
                    var q = MB.Query <MEPatientNote> .EQ(b => b.Id, ObjectId.Parse(pn.Id));

                    var uv = new List <MB.UpdateBuilder>();
                    uv.Add(MB.Update.Set(MEPatientNote.UpdatedByProperty, ObjectId.Parse(this.UserId)));
                    uv.Add(MB.Update.Set(MEPatientNote.VersionProperty, request.Version));
                    uv.Add(MB.Update.Set(MEPatientNote.LastUpdatedOnProperty, System.DateTime.UtcNow));
                    if (pn.PatientId != null)
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.PatientIdProperty, ObjectId.Parse(pn.PatientId)));
                    }
                    if (pn.Text != null)
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.TextProperty, pn.Text));
                    }
                    if (pn.TypeId != null)
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.NoteTypeProperty, ObjectId.Parse(pn.TypeId)));
                    }
                    if (pn.ProgramIds != null && pn.ProgramIds.Count > 0)
                    {
                        uv.Add(MB.Update.SetWrapped <List <ObjectId> >(MEPatientNote.ProgramProperty, Helper.ConvertToObjectIdList(pn.ProgramIds)));
                    }
                    else
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.ProgramProperty, BsonNull.Value));
                    }
                    if (pn.MethodId != null)
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.MethodIdProperty, ObjectId.Parse(pn.MethodId)));
                    }
                    else
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.MethodIdProperty, BsonNull.Value));
                    }
                    if (pn.WhoId != null)
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.WhoIdProperty, pn.WhoId));
                    }
                    else
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.WhoIdProperty, BsonNull.Value));
                    }
                    if (pn.SourceId != null)
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.SourceIdProperty, pn.SourceId));
                    }
                    else
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.SourceIdProperty, BsonNull.Value));
                    }
                    if (pn.OutcomeId != null)
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.OutcomeIdProperty, pn.OutcomeId));
                    }
                    else
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.OutcomeIdProperty, BsonNull.Value));
                    }
                    if (pn.Duration != null)
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.DurationProperty, pn.Duration));
                    }
                    else
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.DurationProperty, BsonNull.Value));
                    }
                    uv.Add(MB.Update.Set(MEPatientNote.ValidatedIdentityProperty, pn.ValidatedIdentity));
                    if (pn.ContactedOn != null && !pn.ContactedOn.Equals(new DateTime()))
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.ContactedOnProperty, pn.ContactedOn));
                    }
                    else
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.ContactedOnProperty, BsonNull.Value));
                    }

                    if (pn.DataSource != null)
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.DataSourceProperty, Helper.TrimAndLimit(pn.DataSource, 50)));
                    }
                    else
                    {
                        uv.Add(MB.Update.Set(MEPatientNote.DataSourceProperty, BsonNull.Value));
                    }

                    IMongoUpdate update = MB.Update.Combine(uv);
                    ctx.PatientNotes.Collection.Update(q, update);

                    AuditHelper.LogDataAudit(this.UserId,
                                             MongoCollectionName.PatientNote.ToString(),
                                             pn.Id,
                                             DataAuditType.Update,
                                             request.ContractNumber);

                    result = true;
                }
                return(result as object);
            }
            catch (Exception) { throw; }
        }