public object Insert(object newEntity)
{
var data = newEntity as PatientUtilizationData;
string noteId = string.Empty;
try
{
if (data != null)
{
var meN = new MEPatientUtilization(this.UserId)
{
DeleteFlag = false,
OtherDisposition = Trim(data.OtherDisposition, 100),
OtherLocation = Trim(data.OtherLocation, 100),
OtherType = Trim(data.OtherType, 100),
ProgramIds = data.ProgramIds != null?data.ProgramIds.ConvertAll(ObjectId.Parse) : null,
DataSource = data.DataSource = Helper.TrimAndLimit(data.DataSource, 50),
Reason = data.Reason = Helper.TrimAndLimit(data.Reason, 5000),
Version = 1,
Admitted = data.Admitted
};
if (data.AdmitDate != null && !data.AdmitDate.Equals(new DateTime()))
{
meN.AdmitDate = data.AdmitDate = data.AdmitDate.GetValueOrDefault().ToUniversalTime();
}
else
{
data.AdmitDate = null;
}
if (data.DischargeDate != null && !data.DischargeDate.Equals(new DateTime()))
{
meN.DischargeDate = data.DischargeDate = data.DischargeDate.GetValueOrDefault().ToUniversalTime();
}
else
{
data.DischargeDate = null;
}
if (!string.IsNullOrEmpty(data.DispositionId))
{
meN.Disposition = ObjectId.Parse(data.DispositionId);
}
if (!string.IsNullOrEmpty(data.LocationId))
{
meN.Location = ObjectId.Parse(data.LocationId);
}
if (!string.IsNullOrEmpty(data.SourceId))
{
meN.SourceId = ObjectId.Parse(data.SourceId);
}
if (!string.IsNullOrEmpty(data.VisitTypeId))
{
meN.VisitType = ObjectId.Parse(data.VisitTypeId);
}
if (!string.IsNullOrEmpty(data.PatientId))
{
meN.PatientId = ObjectId.Parse(data.PatientId);
}
if (!string.IsNullOrEmpty(data.TypeId))
{
meN.NoteType = ObjectId.Parse(data.TypeId);
}
using (Context)
{
Context.PatientUtilizations.Collection.Insert(meN);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientUtilization.ToString(),
meN.Id.ToString(),
DataAuditType.Insert,
ContractDBName);
noteId = meN.Id.ToString();
}
data.CreatedById = meN.RecordCreatedBy.ToString();
data.CreatedOn = meN.RecordCreatedOn;
data.Id = meN.Id.ToString();
}
return(data);
}
catch (Exception ex)
{
throw ex;
}
}
public object Update(object entity)
{
bool result = false;
PutPatientAllergyDataRequest pa = (PutPatientAllergyDataRequest)entity;
PatientAllergyData pt = pa.PatientAllergyData;
try
{
using (AllergyMongoContext ctx = new AllergyMongoContext(ContractDBName))
{
var q = MB.Query <MEPatientAllergy> .EQ(b => b.Id, ObjectId.Parse(pt.Id));
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEPatientAllergy.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEPatientAllergy.VersionProperty, pa.Version));
uv.Add(MB.Update.Set(MEPatientAllergy.LastUpdatedOnProperty, System.DateTime.UtcNow));
if (pt.PatientId != null)
{
uv.Add(MB.Update.Set(MEPatientAllergy.PatientIdProperty, ObjectId.Parse(pt.PatientId)));
}
if (pt.AllergyId != null)
{
uv.Add(MB.Update.Set(MEPatientAllergy.AllergyIdProperty, ObjectId.Parse(pt.AllergyId)));
}
if (pt.SeverityId != null)
{
uv.Add(MB.Update.Set(MEPatientAllergy.SeverityIdProperty, ObjectId.Parse(pt.SeverityId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientAllergy.SeverityIdProperty, BsonNull.Value));
}
if (pt.ReactionIds != null && pt.ReactionIds.Count > 0)
{
uv.Add(MB.Update.SetWrapped <List <ObjectId> >(MEPatientAllergy.ReactionIdsProperty, Helper.ConvertToObjectIdList(pt.ReactionIds)));
}
else
{
uv.Add(MB.Update.Set(MEPatientAllergy.ReactionIdsProperty, BsonNull.Value));
}
if (pt.StartDate != null)
{
uv.Add(MB.Update.Set(MEPatientAllergy.StartDateProperty, pt.StartDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientAllergy.StartDateProperty, BsonNull.Value));
}
if (pt.EndDate != null)
{
uv.Add(MB.Update.Set(MEPatientAllergy.EndDateProperty, pt.EndDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientAllergy.EndDateProperty, BsonNull.Value));
}
if (pt.StatusId != 0)
{
uv.Add(MB.Update.Set(MEPatientAllergy.StatusProperty, pt.StatusId));
}
if (pt.SourceId != null)
{
uv.Add(MB.Update.Set(MEPatientAllergy.SourceIdProperty, ObjectId.Parse(pt.SourceId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientAllergy.SourceIdProperty, BsonNull.Value));
}
if (pt.DataSource != null)
{
uv.Add(MB.Update.Set(MEPatientAllergy.DataSourceProperty, pt.DataSource));
}
else
{
uv.Add(MB.Update.Set(MEPatientAllergy.DataSourceProperty, BsonNull.Value));
}
if (pt.ExternalRecordId != null)
{
uv.Add(MB.Update.Set(MEPatientAllergy.ExternalRecordIdProperty, pt.ExternalRecordId));
}
else
{
uv.Add(MB.Update.Set(MEPatientAllergy.ExternalRecordIdProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(pt.CodingSystemId))
{
uv.Add(MB.Update.Set(MEPatientAllergy.CodingSystemProperty, ObjectId.Parse(pt.CodingSystemId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientAllergy.CodingSystemProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(pt.Code))
{
uv.Add(MB.Update.Set(MEPatientAllergy.CodeProperty, pt.Code));
}
else
{
uv.Add(MB.Update.Set(MEPatientAllergy.CodeProperty, BsonNull.Value));
}
if (pt.Notes != null)
{
uv.Add(MB.Update.Set(MEPatientAllergy.NotesProperty, pt.Notes));
}
if (pt.SystemName != null)
{
uv.Add(MB.Update.Set(MEPatientAllergy.SystemProperty, pt.SystemName));
}
uv.Add(MB.Update.Set(MEPatientAllergy.DeleteFlagProperty, pt.DeleteFlag));
DataAuditType type;
if (pt.DeleteFlag)
{
uv.Add(MB.Update.Set(MEPatientAllergy.TTLDateProperty, System.DateTime.UtcNow.AddDays(_expireDays)));
type = DataAuditType.Delete;
}
else
{
uv.Add(MB.Update.Set(MEPatientAllergy.TTLDateProperty, BsonNull.Value));
type = DataAuditType.Update;
}
IMongoUpdate update = MB.Update.Combine(uv);
ctx.PatientAllergies.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientAllergy.ToString(),
pt.Id,
type,
pa.ContractNumber);
result = true;
}
return(result as object);
}
catch (Exception) { throw; }
}
public object Update(object entity)
{
PatientUtilizationData pn = entity as PatientUtilizationData;
try
{
PatientUtilizationData result;
using (PatientNoteMongoContext ctx = new PatientNoteMongoContext(ContractDBName))
{
var q = MB.Query <MEPatientUtilization> .EQ(b => b.Id, ObjectId.Parse(pn.Id));
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEPatientUtilization.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEPatientUtilization.LastUpdatedOnProperty, DateTime.UtcNow));
uv.Add(MB.Update.Set(MEPatientUtilization.AdmittedProperty, pn.Admitted));
if (pn.OtherType != null)
{
uv.Add(MB.Update.Set(MEPatientUtilization.OtherTypeProperty, Trim(pn.OtherType, 100)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.OtherTypeProperty, BsonNull.Value));
}
if (pn.OtherLocation != null)
{
uv.Add(MB.Update.Set(MEPatientUtilization.OtherLocationProperty, Trim(pn.OtherLocation, 100)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.OtherLocationProperty, BsonNull.Value));
}
if (pn.Reason != null)
{
uv.Add(MB.Update.Set(MEPatientUtilization.ReasonProperty, Trim(pn.Reason, 5000)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.ReasonProperty, BsonNull.Value));
}
if (pn.OtherDisposition != null)
{
uv.Add(MB.Update.Set(MEPatientUtilization.OtherDispositionProperty, Trim(pn.OtherDisposition, 100)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.OtherDispositionProperty, BsonNull.Value));
}
if (pn.DataSource != null)
{
uv.Add(MB.Update.Set(MEPatientUtilization.DataSourceProperty, Trim(pn.DataSource, 50)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.DataSourceProperty, BsonNull.Value));
}
if (pn.AdmitDate != null && !pn.AdmitDate.Equals(new DateTime()))
{
uv.Add(MB.Update.Set(MEPatientUtilization.AdmitDateProperty, pn.AdmitDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.AdmitDateProperty, BsonNull.Value));
}
if (pn.DischargeDate != null && !pn.DischargeDate.Equals(new DateTime()))
{
uv.Add(MB.Update.Set(MEPatientUtilization.DischargeDateProperty, pn.DischargeDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.DischargeDateProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(pn.PatientId))
{
uv.Add(MB.Update.Set(MEPatientUtilization.PatientIdProperty, ObjectId.Parse(pn.PatientId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.PatientIdProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(pn.VisitTypeId))
{
uv.Add(MB.Update.Set(MEPatientUtilization.VisitTypeProperty, ObjectId.Parse(pn.VisitTypeId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.VisitTypeProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(pn.LocationId))
{
uv.Add(MB.Update.Set(MEPatientUtilization.LocationProperty, ObjectId.Parse(pn.LocationId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.LocationProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(pn.DispositionId))
{
uv.Add(MB.Update.Set(MEPatientUtilization.DispositionProperty, ObjectId.Parse(pn.DispositionId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.DispositionProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(pn.SourceId))
{
uv.Add(MB.Update.Set(MEPatientUtilization.SourceIdProperty, ObjectId.Parse(pn.SourceId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.SourceIdProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(pn.TypeId))
{
uv.Add(MB.Update.Set(MEPatientUtilization.NoteTypeProperty, ObjectId.Parse(pn.TypeId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.NoteTypeProperty, BsonNull.Value));
}
if (pn.ProgramIds != null && pn.ProgramIds.Count > 0)
{
uv.Add(MB.Update.SetWrapped <List <ObjectId> >(MEPatientUtilization.ProgramsProperty,
Helper.ConvertToObjectIdList(pn.ProgramIds)));
}
else
{
uv.Add(MB.Update.Set(MEPatientUtilization.ProgramsProperty, BsonNull.Value));
}
IMongoUpdate update = MB.Update.Combine(uv);
ctx.PatientUtilizations.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientUtilization.ToString(),
pn.Id,
DataAuditType.Update,
ContractDBName);
result = FindByID(pn.Id) as PatientUtilizationData;
}
return(result as object);
}
catch (Exception)
{
throw;
}
}
public object Update(object entity)
{
bool result = false;
PutPatientMedSuppDataRequest request = (PutPatientMedSuppDataRequest)entity;
PatientMedSuppData data = request.PatientMedSuppData;
try
{
using (MedicationMongoContext ctx = new MedicationMongoContext(ContractDBName))
{
var q = MB.Query <MEPatientMedSupp> .EQ(b => b.Id, ObjectId.Parse(data.Id));
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEPatientMedSupp.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEPatientMedSupp.VersionProperty, request.Version));
uv.Add(MB.Update.Set(MEPatientMedSupp.LastUpdatedOnProperty, System.DateTime.UtcNow));
if (data.PatientId != null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.PatientIdProperty, ObjectId.Parse(data.PatientId)));
}
if (!string.IsNullOrEmpty(data.Name))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.NameProperty, data.Name.ToUpper()));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.NameProperty, BsonNull.Value));
}
//if (data.FamilyId != null)
//{
// uv.Add(MB.Update.Set(MEPatientMedSupp.FamilyIdProperty, ObjectId.Parse(data.FamilyId)));
//}
//else
//{
// uv.Add(MB.Update.Set(MEPatientMedSupp.FamilyIdProperty, BsonNull.Value));
//}
if (data.CategoryId != 0)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.CategoryProperty, data.CategoryId));
}
if (data.TypeId != null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.TypeIdProperty, ObjectId.Parse(data.TypeId)));
}
if (data.StatusId != 0)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.StatusProperty, data.StatusId));
}
if (!string.IsNullOrEmpty(data.Dosage))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.DosageProperty, data.Dosage));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.DosageProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(data.Strength))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.StrengthProperty, data.Strength));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.StrengthProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(data.Form))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.FormProperty, data.Form.ToUpper()));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.FormProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(data.Route))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.RouteProperty, data.Route.ToUpper()));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.RouteProperty, BsonNull.Value));
}
uv.Add(MB.Update.SetWrapped <List <string> >(MEPatientMedSupp.PharmClassProperty, (data.PharmClasses != null && data.PharmClasses.Count > 0) ? data.PharmClasses : null));
uv.Add(MB.Update.SetWrapped <List <string> >(MEPatientMedSupp.NDCProperty, (data.NDCs != null && data.NDCs.Count > 0) ? data.NDCs : null));
if (!string.IsNullOrEmpty(data.FreqQuantity))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.FreqQuantityProperty, data.FreqQuantity));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.FreqQuantityProperty, BsonNull.Value));
}
if (data.FreqHowOftenId != null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.FreqHowOftenIdProperty, ObjectId.Parse(data.FreqHowOftenId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.FreqHowOftenIdProperty, BsonNull.Value));
}
if (data.FreqWhenId != null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.FreqWhenIdProperty, ObjectId.Parse(data.FreqWhenId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.FreqWhenIdProperty, BsonNull.Value));
}
if (data.FrequencyId != null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.FrequencyIdProperty, ObjectId.Parse(data.FrequencyId)));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.FrequencyIdProperty, BsonNull.Value));
}
if (data.SourceId != null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.SourceIdProperty, ObjectId.Parse(data.SourceId)));
}
if (data.StartDate != null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.StartDateProperty, data.StartDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.StartDateProperty, BsonNull.Value));
}
if (data.EndDate != null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.EndDateProperty, data.EndDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.EndDateProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(data.Reason))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.ReasonProperty, data.Reason));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.ReasonProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(data.SigCode))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.SigProperty, data.SigCode));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.SigProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(data.Notes))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.NotesProperty, data.Notes));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.NotesProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(data.PrescribedBy))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.PrescribedByProperty, data.PrescribedBy));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.PrescribedByProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(data.DataSource))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.DataSourceProperty, data.DataSource));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.DataSourceProperty, BsonNull.Value));
}
if (!string.IsNullOrEmpty(data.ExternalRecordId))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.ExternalRecordIdProperty, data.ExternalRecordId));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.ExternalRecordIdProperty, BsonNull.Value));
}
if (string.IsNullOrEmpty(data.OriginalDataSource))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.OriginalDataSourceProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.OriginalDataSourceProperty, data.OriginalDataSource));
}
uv.Add(MB.Update.Set(MEPatientMedSupp.DurationProperty, data.Duration));
if (string.IsNullOrEmpty(data.DurationUnitId))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.DurationUnitProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.DurationUnitProperty, ObjectId.Parse(data.DurationUnitId)));
}
if (string.IsNullOrEmpty(data.OtherDuration))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.OtherDurationProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.OtherDurationProperty, data.OtherDuration));
}
if (string.IsNullOrEmpty(data.ReviewId))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.ReviewProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.ReviewProperty, ObjectId.Parse(data.ReviewId)));
}
if (string.IsNullOrEmpty(data.RefusalReasonId))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.RefusalReasonProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.RefusalReasonProperty, ObjectId.Parse(data.RefusalReasonId)));
}
if (string.IsNullOrEmpty(data.OtherRefusalReason))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.OtherRefusalReasonProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.OtherRefusalReasonProperty, data.OtherRefusalReason));
}
if (string.IsNullOrEmpty(data.OrderedBy))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.OrderedByProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.OrderedByProperty, data.OrderedBy));
}
if (data.OrderedDate == null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.OrderedDateProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.OrderedDateProperty, data.OrderedDate));
}
if (data.PrescribedDate == null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.PrescribedDateProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.PrescribedDateProperty, data.PrescribedDate));
}
if (data.RxDate == null)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.RxDateProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.RxDateProperty, data.RxDate));
}
if (string.IsNullOrEmpty(data.Pharmacy))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.PharmacyProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.PharmacyProperty, Helper.TrimAndLimit(data.Pharmacy, 500)));
}
if (string.IsNullOrEmpty(data.RxNumber))
{
uv.Add(MB.Update.Set(MEPatientMedSupp.RxNumberProperty, BsonNull.Value));
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.RxNumberProperty, Helper.TrimAndLimit(data.RxNumber, 50)));
}
uv.Add(MB.Update.Set(MEPatientMedSupp.SystemProperty, data.SystemName));
uv.Add(MB.Update.Set(MEPatientMedSupp.DeleteFlagProperty, data.DeleteFlag));
DataAuditType type;
if (data.DeleteFlag)
{
uv.Add(MB.Update.Set(MEPatientMedSupp.TTLDateProperty, System.DateTime.UtcNow.AddDays(_expireDays)));
type = DataAuditType.Delete;
}
else
{
uv.Add(MB.Update.Set(MEPatientMedSupp.TTLDateProperty, BsonNull.Value));
type = DataAuditType.Update;
}
IMongoUpdate update = MB.Update.Combine(uv);
ctx.PatientMedSupps.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientMedSupp.ToString(),
data.Id,
type,
request.ContractNumber);
result = true;
}
return(result as object);
}
catch (Exception) { throw; }
}
public object Insert(object newEntity)
{
PutPatientMedSuppDataRequest request = (PutPatientMedSuppDataRequest)newEntity;
PatientMedSuppData data = request.PatientMedSuppData;
try
{
using (MedicationMongoContext ctx = new MedicationMongoContext(ContractDBName))
{
MEPatientMedSupp mePMS = new MEPatientMedSupp(this.UserId)
{
PatientId = ObjectId.Parse(data.PatientId),
//FamilyId = string.IsNullOrEmpty(data.FamilyId) ? (ObjectId?)null : ObjectId.Parse(data.FamilyId),
Name = string.IsNullOrEmpty(data.Name) ? null : data.Name.ToUpper(),
CategoryId = (Category)data.CategoryId,
TypeId = ObjectId.Parse(data.TypeId),
StatusId = (Status)data.StatusId,
Dosage = data.Dosage,
Strength = data.Strength,
Route = string.IsNullOrEmpty(data.Route) ? null : data.Route.ToUpper(),
Form = string.IsNullOrEmpty(data.Form) ? null : data.Form.ToUpper(),
PharmClasses = getPharmClassses(ctx, data.Name),
NDCs = (data.NDCs != null && data.NDCs.Count > 0) ? data.NDCs : null,
FreqQuantity = data.FreqQuantity,
FreqHowOftenId = string.IsNullOrEmpty(data.FreqHowOftenId) ? (ObjectId?)null : ObjectId.Parse(data.FreqHowOftenId),
FreqWhenId = string.IsNullOrEmpty(data.FreqWhenId) ? (ObjectId?)null : ObjectId.Parse(data.FreqWhenId),
FrequencyId = string.IsNullOrEmpty(data.FrequencyId) ? (ObjectId?)null : ObjectId.Parse(data.FrequencyId),
SourceId = ObjectId.Parse(data.SourceId),
StartDate = data.StartDate == null ? (DateTime?)null : data.StartDate,
EndDate = data.EndDate == null ? (DateTime?)null : data.EndDate,
Reason = data.Reason,
Notes = data.Notes,
SigCode = data.SigCode,
PrescribedBy = data.PrescribedBy,
SystemName = data.SystemName,
DeleteFlag = false,
DataSource = data.DataSource,
ExternalRecordId = data.ExternalRecordId,
OriginalDataSource = data.OriginalDataSource,
Duration = data.Duration,
DurationUnitId = string.IsNullOrEmpty(data.DurationUnitId) ? (ObjectId?)null : ObjectId.Parse(data.DurationUnitId),
OtherDuration = data.OtherDuration,
ReviewId = string.IsNullOrEmpty(data.ReviewId) ? (ObjectId?)null : ObjectId.Parse(data.ReviewId),
RefusalReasonId = string.IsNullOrEmpty(data.RefusalReasonId) ? (ObjectId?)null : ObjectId.Parse(data.RefusalReasonId),
OtherRefusalReason = data.OtherRefusalReason,
OrderedBy = data.OrderedBy,
OrderedDate = data.OrderedDate,
PrescribedDate = data.PrescribedDate,
RxNumber = Helper.TrimAndLimit(data.RxNumber, 50),
RxDate = data.RxDate,
Pharmacy = Helper.TrimAndLimit(data.Pharmacy, 500)
};
ctx.PatientMedSupps.Collection.Insert(mePMS);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientMedSupp.ToString(),
mePMS.Id.ToString(),
DataAuditType.Insert,
request.ContractNumber);
return(mePMS.Id.ToString());
}
}
catch (Exception) { throw; }
}
/// <summary>
/// Orchestrates common block reading procedures for the <see cref="ReadBlock"/> and
/// <see cref="ReadBlockStreamed"/> methods.
/// </summary>
protected virtual T OrchestrateBlockReading <T>(TTransfer transfer, long blockNumber,
Func <TTransfer, long, DataBlockInfo, T> readerImplFunc) where T : IDataBlock
{
const FileSystemTask context = FileSystemTask.DataBlockDownloadRequest;
if (blockNumber < 0)
{
string msg = "Invalid block number [{0}] requested - block numbers cannot be negative.";
msg = String.Format(msg, blockNumber);
throw new DataBlockException(msg);
}
if (blockNumber >= transfer.Token.TotalBlockCount)
{
string msg = "Invalid block number [{0}] requested - the total number of blocks is [{1}].";
msg = String.Format(msg, blockNumber, transfer.Token.TotalBlockCount);
throw new DataBlockException(msg);
}
//make sure the file still exists
if (!transfer.FileItem.Exists)
{
AuditHelper.AuditRequestedFileNotFound(Auditor, transfer.FileItem, context);
string msg = "Resource [{0}] of transfer [{1}] was not found.";
msg = String.Format(msg, transfer.Token.ResourceName, transfer.TransferId);
throw new VirtualResourceNotFoundException(msg)
{
IsAudited = true
};
}
lock (transfer.SyncRoot) {
//make sure the transfer is active
if (!transfer.Status.Is(TransferStatus.Starting, TransferStatus.Running, TransferStatus.Paused))
{
string msg = String.Format("Transfer [{0}] is not active anymore - status is [{1}].", transfer.TransferId,
transfer.Status);
if (transfer.AbortReason.HasValue)
{
msg += String.Format(" Transfer abort reason: [{0}].", transfer.AbortReason);
}
AuditHelper.AuditDeniedOperation(Auditor, context, AuditEvent.DownloadNoLongerActive, transfer.FileItem as IVirtualFileItem, msg);
throw new TransferStatusException(msg)
{
IsAudited = true, EventId = (int)AuditEvent.DownloadNoLongerActive
};
}
//check whether we already transferred this block once
DataBlockInfo transferredBlock = transfer.TryGetTransferredBlock(blockNumber);
T dataBlock = readerImplFunc(transfer, blockNumber, transferredBlock);
//update status
transfer.Status = TransferStatus.Running;
//store copy of the downloaded block that doesn't contain any data
transfer.RegisterBlock(DataBlockInfo.FromDataBlock(dataBlock));
//audit download
AuditHelper.AuditTransferOperation(Auditor, context, AuditEvent.FileBlockDownloaded, transfer.TransferId, transfer.FileItem as IVirtualFileItem);
return(dataBlock);
}
}
private TTransfer InitTransferImpl(string submittedResourceFilePath, bool overwrite, long resourceLength, string contentType)
{
const FileSystemTask context = FileSystemTask.UploadTokenRequest;
//validate maximum file size
var maxFileSize = GetMaxFileUploadSize();
if (maxFileSize.HasValue && maxFileSize < resourceLength)
{
string msg = "Upload for file [{0}] denied: Resource length of [{1}] is above the maximum upload limit of [{2}] bytes.";
msg = String.Format(msg, submittedResourceFilePath, resourceLength, maxFileSize.Value);
throw new ResourceAccessException(msg);
}
//of course, the length cannot be negative
if (resourceLength < 0)
{
string msg = "Upload for file [{0}] denied: Resource length cannot be negative [{1}].";
msg = String.Format(msg, submittedResourceFilePath, resourceLength);
throw new ResourceAccessException(msg);
}
TFile fileItem = CreateFileItemImpl(submittedResourceFilePath, false, context);
if (fileItem.Exists && !overwrite)
{
AuditHelper.AuditDeniedOperation(Auditor, context, AuditEvent.FileAlreadyExists, fileItem as IVirtualResourceItem <VirtualFileInfo>);
string msg = String.Format("Cannot upload file [{0}] without overwriting existing data - a file already exists at this location.", submittedResourceFilePath);
throw new ResourceOverwriteException(msg)
{
IsAudited = true
};
}
//get authorization
TFolder parentFolder = GetParentFolder(fileItem, context);
//validate file system specific restrictions
VerifyCanUploadFileToFileSystemLocation(submittedResourceFilePath, parentFolder, fileItem);
//get parent folder and check whether files can be added
FolderClaims folderClaims = GetParentFolderClaims(fileItem, parentFolder);
if (!folderClaims.AllowAddFiles)
{
//deny adding a file to that folder
AuditHelper.AuditDeniedOperation(Auditor, context, AuditEvent.CreateFileDenied, fileItem as IVirtualFileItem);
string msg = "Cannot create file at [{0}] - adding files to the folder is not permitted.";
msg = String.Format(msg, submittedResourceFilePath);
throw new ResourceAccessException(msg)
{
IsAudited = true
};
}
//only overwrite a file if explicitly requested
FileClaims claims = GetFileClaims(fileItem);
if (fileItem.Exists)
{
if (!claims.AllowOverwrite)
{
AuditHelper.AuditDeniedOperation(Auditor, context, AuditEvent.FileDataOverwriteDenied, fileItem as IVirtualFileItem);
string msg = "Overwriting file [{0}] was denied due to missing permission.";
msg = String.Format(msg, submittedResourceFilePath);
throw new ResourceOverwriteException(msg)
{
IsAudited = true
};
}
}
//try to get lock
ResourceLockGuard writeLock = LockResourceForUpload(fileItem);
if (writeLock != null && !writeLock.IsLockEnabled)
{
AuditHelper.AuditDeniedOperation(Auditor, context, AuditEvent.FileReadLockDenied, fileItem as IVirtualFileItem);
string msg = "The file [{0}] is currently locked and cannot be accessed.";
msg = String.Format(msg, submittedResourceFilePath);
throw new ResourceLockedException(msg)
{
IsAudited = true
};
}
//create upload token
UploadToken token = CreateUploadToken(submittedResourceFilePath, fileItem, resourceLength, contentType);
//create expiration job if we have an expiration time
Job <UploadToken> job = null;
if (token.ExpirationTime.HasValue)
{
job = ScheduleExpiration(token);
}
//create and cache transfer instance
TTransfer transfer = CreateTransfer(submittedResourceFilePath, fileItem, parentFolder, token, claims, writeLock, job);
TransferStore.AddTransfer(transfer);
AuditHelper.AuditResourceOperation(Auditor, context, AuditEvent.UploadTokenIssued, fileItem as IVirtualFileItem);
return(transfer);
}
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; }
}
object IRepository.Update(object entity)
{
bool result = false;
PutUpdateObservationDataRequest odr = (PutUpdateObservationDataRequest)entity;
PatientObservationRecordData pord = odr.PatientObservationData;
try
{
using (PatientObservationMongoContext ctx = new PatientObservationMongoContext(_dbName))
{
var q = MB.Query <MEPatientObservation> .EQ(b => b.Id, ObjectId.Parse(pord.Id));
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEPatientObservation.DeleteFlagProperty, pord.DeleteFlag));
if (pord.DeleteFlag)
{
uv.Add(MB.Update.Set(MEPatientObservation.TTLDateProperty, System.DateTime.UtcNow.AddDays(_expireDays)));
}
else
{
uv.Add(MB.Update.Set(MEPatientObservation.TTLDateProperty, BsonNull.Value));
}
uv.Add(MB.Update.Set(MEPatientObservation.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEPatientObservation.LastUpdatedOnProperty, System.DateTime.UtcNow));
uv.Add(MB.Update.Set(MEPatientObservation.VersionProperty, odr.Version));
if (pord.NonNumericValue != null)
{
uv.Add(MB.Update.Set(MEPatientObservation.NonNumericValueProperty, pord.NonNumericValue));
}
if (pord.Value != null)
{
uv.Add(MB.Update.Set(MEPatientObservation.NumericValueProperty, BsonDouble.Create(pord.Value)));
}
if (pord.Units != null)
{
uv.Add(MB.Update.Set(MEPatientObservation.UnitsProperty, pord.Units));
}
if (pord.StartDate != null)
{
uv.Add(MB.Update.Set(MEPatientObservation.StartDateProperty, pord.StartDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientObservation.StartDateProperty, BsonNull.Value));
}
if (pord.EndDate != null)
{
uv.Add(MB.Update.Set(MEPatientObservation.EndDateProperty, pord.EndDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientObservation.EndDateProperty, BsonNull.Value));
}
if (pord.DisplayId != 0)
{
uv.Add(MB.Update.Set(MEPatientObservation.DisplayProperty, pord.DisplayId));
}
if (pord.StateId != 0)
{
uv.Add(MB.Update.Set(MEPatientObservation.ObservationStateProperty, pord.StateId));
}
if (pord.Source != null)
{
uv.Add(MB.Update.Set(MEPatientObservation.SourceProperty, pord.Source));
}
if (pord.DataSource != null)
{
uv.Add(MB.Update.Set(MEPatientObservation.DataSourceProperty, pord.DataSource));
}
else
{
uv.Add(MB.Update.Set(MEPatientObservation.DataSourceProperty, BsonNull.Value));
}
if (pord.ExternalRecordId != null)
{
uv.Add(MB.Update.Set(MEPatientObservation.ExternalRecordIdProperty, pord.ExternalRecordId));
}
else
{
uv.Add(MB.Update.Set(MEPatientObservation.ExternalRecordIdProperty, BsonNull.Value));
}
IMongoUpdate update = MB.Update.Combine(uv);
ctx.PatientObservations.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientObservation.ToString(),
pord.Id,
Common.DataAuditType.Update,
odr.ContractNumber);
result = true;
}
return(result as object);
}
catch (Exception ex) { throw new Exception("PatientObservationDD:MongoPatientBarrierRepository:Update()::" + ex.Message, ex.InnerException); }
}
public object Update(object entity)
{
bool result = false;
PutUpdateTaskRequest ptr = (PutUpdateTaskRequest)entity;
PatientTaskData pt = ptr.Task;
try
{
using (PatientGoalMongoContext ctx = new PatientGoalMongoContext(_dbName))
{
var q = MB.Query <MEPatientTask> .EQ(b => b.Id, ObjectId.Parse(pt.Id));
// Set the StatusDate to Now if the status is changed.
MEPatientTask existingPB = ctx.PatientTasks.Collection.Find(q).SetFields(MEPatientTask.StatusProperty).FirstOrDefault();
if (existingPB != null)
{
if ((int)existingPB.Status != pt.StatusId)
{
pt.StatusDate = DateTime.UtcNow;
}
}
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEPatientTask.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEPatientTask.VersionProperty, ptr.Version));
uv.Add(MB.Update.Set(MEPatientTask.LastUpdatedOnProperty, System.DateTime.UtcNow));
if (pt.Description != null)
{
uv.Add(MB.Update.Set(MEPatientTask.DescriptionProperty, pt.Description));
}
if (pt.StartDate != null)
{
uv.Add(MB.Update.Set(MEPatientTask.StartDateProperty, pt.StartDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientTask.StartDateProperty, BsonNull.Value));
}
if (pt.StatusDate != null)
{
uv.Add(MB.Update.Set(MEPatientTask.StatusDateProperty, pt.StatusDate));
}
if (pt.StatusId != 0)
{
uv.Add(MB.Update.Set(MEPatientTask.StatusProperty, pt.StatusId));
}
if (pt.TargetDate != null)
{
uv.Add(MB.Update.Set(MEPatientTask.TargetDateProperty, pt.TargetDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientTask.TargetDateProperty, BsonNull.Value));
}
if (pt.TargetValue != null)
{
uv.Add(MB.Update.Set(MEPatientTask.TargetValueProperty, pt.TargetValue));
}
if (pt.CustomAttributes != null)
{
uv.Add(MB.Update.SetWrapped <List <MAttribute> >(MEPatientTask.AttributesProperty, DTOUtil.GetAttributes(pt.CustomAttributes)));
}
if (pt.BarrierIds != null)
{
uv.Add(MB.Update.SetWrapped <List <ObjectId> >(MEPatientTask.BarriersProperty, DTOUtil.ConvertObjectId(pt.BarrierIds)));
}
if (pt.PatientGoalId != null)
{
uv.Add(MB.Update.Set(MEPatientTask.PatientGoalIdProperty, ObjectId.Parse(pt.PatientGoalId)));
}
uv.Add(MB.Update.Set(MEPatientTask.ClosedDateProperty, pt.ClosedDate));
uv.Add(MB.Update.Set(MEPatientTask.DeleteFlagProperty, pt.DeleteFlag));
DataAuditType type;
if (pt.DeleteFlag)
{
uv.Add(MB.Update.Set(MEPatientTask.TTLDateProperty, System.DateTime.UtcNow.AddDays(_expireDays)));
type = Common.DataAuditType.Delete;
}
else
{
uv.Add(MB.Update.Set(MEPatientTask.TTLDateProperty, BsonNull.Value));
type = Common.DataAuditType.Update;
}
IMongoUpdate update = MB.Update.Combine(uv);
ctx.PatientTasks.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientTask.ToString(),
pt.Id,
type,
ptr.ContractNumber);
result = true;
}
return(result as object);
}
catch (Exception) { throw; }
}
public override bool OnReceiveRequest(ClearCanvas.Dicom.Network.DicomServer server,
ServerAssociationParameters association, byte presentationID, DicomMessage message)
{
string studyInstanceUid;
string seriesInstanceUid;
DicomUid sopInstanceUid;
bool ok = message.DataSet[DicomTags.SopInstanceUid].TryGetUid(0, out sopInstanceUid);
if (ok)
{
ok = message.DataSet[DicomTags.SeriesInstanceUid].TryGetString(0, out seriesInstanceUid);
}
if (ok)
{
ok = message.DataSet[DicomTags.StudyInstanceUid].TryGetString(0, out studyInstanceUid);
}
if (!ok)
{
Platform.Log(LogLevel.Error, "Unable to retrieve UIDs from request message, sending failure status.");
server.SendCStoreResponse(presentationID, message.MessageId, sopInstanceUid.UID,
DicomStatuses.ProcessingFailure);
return(true);
}
if (_importContext == null)
{
_importContext = new DicomReceiveImportContext(association.CallingAE, GetRemoteHostName(association), StudyStore.GetConfiguration(), EventSource.CurrentProcess);
// Publish new WorkItems as they're added to the context
lock (_importContext.StudyWorkItemsSyncLock)
{
_importContext.StudyWorkItems.ItemAdded += delegate(object sender, DictionaryEventArgs <string, WorkItem> args)
{
Platform.GetService(
(IWorkItemActivityMonitorService service) =>
service.Publish(new WorkItemPublishRequest
{
Item =
WorkItemDataHelper
.FromWorkItem(
args.Item)
}));
var auditedInstances = new AuditedInstances();
var request =
args.Item.Request as DicomReceiveRequest;
if (request != null)
{
auditedInstances.AddInstance(request.Patient.PatientId, request.Patient.PatientsName,
request.Study.StudyInstanceUid);
}
AuditHelper.LogReceivedInstances(
association.CallingAE, GetRemoteHostName(association),
auditedInstances, EventSource.CurrentProcess,
EventResult.Success, EventReceiptAction.ActionUnknown);
}
;
_importContext.StudyWorkItems.ItemChanged += (sender, args) => Platform.GetService(
(IWorkItemActivityMonitorService service) =>
service.Publish(new WorkItemPublishRequest {
Item = WorkItemDataHelper.FromWorkItem(args.Item)
}));
}
}
var importer = new ImportFilesUtility(_importContext);
var result = importer.Import(message, BadFileBehaviourEnum.Ignore, FileImportBehaviourEnum.Save);
if (result.Successful)
{
if (!String.IsNullOrEmpty(result.AccessionNumber))
{
Platform.Log(LogLevel.Info, "Received SOP Instance {0} from {1} to {2} (A#:{3} StudyUid:{4})",
result.SopInstanceUid, association.CallingAE, association.CalledAE, result.AccessionNumber,
result.StudyInstanceUid);
}
else
{
Platform.Log(LogLevel.Info, "Received SOP Instance {0} from {1} to {2} (StudyUid:{3})",
result.SopInstanceUid, association.CallingAE, association.CalledAE,
result.StudyInstanceUid);
}
server.SendCStoreResponse(presentationID, message.MessageId, message.AffectedSopInstanceUid, result.DicomStatus);
}
else
{
if (result.DicomStatus == DicomStatuses.ProcessingFailure)
{
Platform.Log(LogLevel.Error, "Failure importing sop: {0}", result.ErrorMessage);
}
//OnReceiveError(message, result.ErrorMessage, association.CallingAE);
server.SendCStoreResponse(presentationID, message.MessageId, message.AffectedSopInstanceUid,
result.DicomStatus, result.ErrorMessage);
}
return(true);
}
/// <summary>
/// Main Processing routine.
/// </summary>
public override void Process()
{
bool stillProcessing = ProcessUidList();
if (CancelPending)
{
Proxy.Cancel();
return;
}
if (StopPending)
{
Proxy.Idle();
return;
}
if (!stillProcessing)
{
bool failed = false;
bool complete = true;
bool filesMissing = false;
foreach (WorkItemUid sop in WorkQueueUidList)
{
if (sop.Failed)
{
//If any items failed simply because the file doesn't exist, then fail outright.
if (!File.Exists(GetFilePath(sop)))
{
filesMissing = true;
}
failed = true;
break;
}
if (!sop.Complete)
{
complete = false;
break;
}
}
DateTime now = Platform.Time;
if (failed)
{
var failureType = filesMissing ? WorkItemFailureType.Fatal : WorkItemFailureType.NonFatal;
Proxy.Fail(failureType);
if (Proxy.Item.Status == WorkItemStatusEnum.Failed)
{
var auditedInstances = new AuditedInstances();
auditedInstances.AddInstance(Request.Patient.PatientId, Request.Patient.PatientsName, Request.Study.StudyInstanceUid);
AuditHelper.LogImportStudies(auditedInstances,
string.IsNullOrEmpty(Request.UserName)
? EventSource.CurrentProcess
: EventSource.GetUserEventSource(Request.UserName),
EventResult.MajorFailure);
}
}
else if (!complete)
{
Proxy.Idle();
}
else if (now > Proxy.Item.ExpirationTime)
{
if (Study == null)
{
Study = LoadRelatedStudy();
}
var ruleOptions = new RulesEngineOptions
{
ApplyDeleteActions = true,
ApplyRouteActions = true
};
RulesEngine.Create().ApplyStudyRules(Study.ToStoreEntry(), ruleOptions);
Proxy.Complete();
var auditedInstances = new AuditedInstances();
auditedInstances.AddInstance(Request.Patient.PatientId, Request.Patient.PatientsName,
Request.Study.StudyInstanceUid);
AuditHelper.LogImportStudies(auditedInstances,
string.IsNullOrEmpty(Request.UserName)
? EventSource.CurrentProcess
: EventSource.GetUserEventSource(Request.UserName),
EventResult.Success);
}
else
{
Proxy.Idle();
}
}
else
{
Proxy.Idle();
}
}
public object Insert(object newEntity)
{
bool result = false;
ProgramAttributeData pa = (ProgramAttributeData)newEntity;
MEProgramAttribute mepa = null;
try
{
using (ProgramMongoContext ctx = new ProgramMongoContext(_dbName))
{
mepa = new MEProgramAttribute(this.UserId)
{
Status = (Status)pa.Status,
RemovedReason = pa.OverrideReason,
Population = pa.Population,
PlanElementId = ObjectId.Parse(pa.PlanElementId),
OverrideReason = pa.OverrideReason,
//OptOutReason = pa.OptOutReason,
//OptOutDate = pa.OptOutDate,
OptOut = pa.OptOut,
Locked = (Locked)pa.Locked,
IneligibleReason = pa.IneligibleReason,
Completed = (Completed)pa.Completed,
//AssignedOn = pa.AssignedOn, Sprint 12
CompletedBy = pa.CompletedBy,
DateCompleted = pa.DateCompleted,
DidNotEnrollReason = pa.DidNotEnrollReason,
//DisEnrollReason = pa.DisEnrollReason,
Eligibility = (EligibilityStatus)pa.Eligibility,
//EligibilityEndDate = pa.EligibilityEndDate,
//EligibilityOverride = (EligibilityOverride)pa.EligibilityOverride,
//EligibilityRequirements = pa.EligibilityRequirements,
//EligibilityStartDate = pa.EligibilityStartDate,
// EndDate = pa.AttrEndDate, , Sprint 12
Enrollment = (EnrollmentStatus)pa.Enrollment,
GraduatedFlag = (Graduated)pa.GraduatedFlag,
// StartDate = pa.AttrStartDate, Sprint 12
DeleteFlag = false
//,LastUpdatedOn = DateTime.UtcNow,
//UpdatedBy = ObjectId.Parse(this.UserId)
};
//if(pa.AssignedBy != null) Sprint 12
//{
// mepa.AssignedBy = ObjectId.Parse(pa.AssignedBy);
//}
//if (pa.AssignedTo != null) Sprint 12
//{
// mepa.AssignedTo = ObjectId.Parse(pa.AssignedTo);
//}
ctx.ProgramAttributes.Collection.Insert(mepa);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientProgramAttribute.ToString(),
mepa.Id.ToString(),
Common.DataAuditType.Insert,
_dbName);
result = true;
}
return(result);
}
catch (Exception ex)
{
throw new Exception("DD:PatientProgramAttributeRepository:Insert()::" + ex.Message, ex.InnerException);
}
}
public object Update(object entity)
{
ProgramAttributeData mepa = (ProgramAttributeData)entity;
bool result = false;
try
{
using (ProgramMongoContext ctx = new ProgramMongoContext(_dbName))
{
var q = MB.Query <MEProgramAttribute> .EQ(b => b.PlanElementId, ObjectId.Parse(mepa.PlanElementId));
var uv = new List <MB.UpdateBuilder>();
// state
//if (mepa.AssignedBy != null) uv.Add(MB.Update.Set(MEProgramAttribute.AssignByProperty, mepa.AssignedBy));
//if (mepa.AssignedTo != null) uv.Add(MB.Update.Set(MEProgramAttribute.AssignToProperty, mepa.AssignedTo));
//if (mepa.AssignedOn != null) uv.Add(MB.Update.Set(MEProgramAttribute.AssignDateProperty, mepa.AssignedOn));
if (mepa.Population != null)
{
uv.Add(MB.Update.Set(MEProgramAttribute.PopulationProperty, mepa.Population));
}
if (mepa.Completed != 0)
{
uv.Add(MB.Update.Set(MEProgramAttribute.CompletedProperty, mepa.Completed));
}
if (mepa.CompletedBy != null)
{
uv.Add(MB.Update.Set(MEProgramAttribute.CompletedByProperty, mepa.CompletedBy));
}
if (mepa.DateCompleted != null)
{
uv.Add(MB.Update.Set(MEProgramAttribute.CompletedOnProperty, mepa.DateCompleted));
}
if (mepa.RemovedReason != null)
{
uv.Add(MB.Update.Set(MEProgramAttribute.RemovedReasonProperty, mepa.RemovedReason));
}
if (mepa.GraduatedFlag != 0)
{
uv.Add(MB.Update.Set(MEProgramAttribute.GraduatedFlagProperty, mepa.GraduatedFlag));
}
if (mepa.Locked != 0)
{
uv.Add(MB.Update.Set(MEProgramAttribute.LockedProperty, mepa.Locked));
}
if (mepa.OverrideReason != null)
{
uv.Add(MB.Update.Set(MEProgramAttribute.OverrideReasonProperty, mepa.OverrideReason));
}
if (mepa.Status != 0)
{
uv.Add(MB.Update.Set(MEProgramAttribute.StatusProperty, (Status)mepa.Status));
}
// eligibility
//if (mepa.EligibilityEndDate != null) uv.Add(MB.Update.Set(MEProgramAttribute.EligibilityEndDateProperty, mepa.EligibilityEndDate));
//if (mepa.EligibilityRequirements != null) uv.Add(MB.Update.Set(MEProgramAttribute.EligibilityRequirementsProperty, mepa.EligibilityRequirements));
//if (mepa.EligibilityStartDate != null) uv.Add(MB.Update.Set(MEProgramAttribute.EligibilityStartDateProperty, mepa.EligibilityStartDate));
if (mepa.IneligibleReason != null)
{
uv.Add(MB.Update.Set(MEProgramAttribute.IneligibleReasonProperty, mepa.IneligibleReason));
}
//if (mepa.EligibilityOverride != 0) uv.Add(MB.Update.Set(MEProgramAttribute.EligibilityOverrideProperty, (EligibilityOverride)mepa.EligibilityOverride));
if (mepa.Eligibility != 0)
{
uv.Add(MB.Update.Set(MEProgramAttribute.EligibilityProperty, (EligibilityStatus)mepa.Eligibility));
}
// optout
//if (mepa.OptOutDate != null) uv.Add(MB.Update.Set(MEProgramAttribute.OptOutDateProperty, mepa.OptOutDate));
if (mepa.OptOut != null)
{
uv.Add(MB.Update.Set(MEProgramAttribute.OptOutProperty, mepa.OptOut));
}
//if (mepa.OptOutReason != null) uv.Add(MB.Update.Set(MEProgramAttribute.OptOutReasonProperty, mepa.OptOutReason));
// dates
//if (mepa.AttrStartDate != null) uv.Add(MB.Update.Set(MEProgramAttribute.StartDateProperty, mepa.AttrStartDate)); Sprint 12
//if (mepa.AttrEndDate != null) uv.Add(MB.Update.Set(MEProgramAttribute.EndDateProperty, mepa.AttrEndDate)); Sprint 12
// enrollment
if (mepa.Enrollment != 0)
{
uv.Add(MB.Update.Set(MEProgramAttribute.EnrollmentProperty, (EnrollmentStatus)mepa.Enrollment));
}
if (mepa.DidNotEnrollReason != null)
{
uv.Add(MB.Update.Set(MEProgramAttribute.DidNotEnrollReasonProperty, mepa.DidNotEnrollReason));
}
//if (mepa.DisEnrollReason != null) uv.Add(MB.Update.Set(MEProgramAttribute.DisEnrollReasonProperty, mepa.DisEnrollReason));
uv.Add(MB.Update.Set(MEProgramAttribute.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEProgramAttribute.LastUpdatedOnProperty, DateTime.UtcNow));
if (uv.Count > 0)
{
IMongoUpdate update = MB.Update.Combine(uv);
ctx.ProgramAttributes.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientProgramAttribute.ToString(),
mepa.PlanElementId,
MEProgramAttribute.PlanElementIdProperty,
Common.DataAuditType.Update,
_dbName);
result = true;
}
}
return(result);
}
catch (Exception ex)
{
throw new Exception("DD:PatientProgramAttributeRepository:Update()::" + ex.Message, ex.InnerException);
}
}
public bool SaveAll(bool promptForLocation)
{
// warn if there appear to be any reports or attachments in the files being edited
if (!WarnSaveEditedReportsOrAttachments())
{
return(false);
}
// prompt for destination if requested or any files are from local data store
var filenameMap = (Dictionary <string, string>)null;
if ((promptForLocation || AnyFilesFromLocalStore()) && !PromptSaveDestination(out filenameMap))
{
return(false);
}
// if destination was not prompted, warn user that files will be overwritten
if (filenameMap == null && !WarnOverwriteFiles())
{
return(false);
}
var modifiedInstances = new AuditedInstances();
var failureCount = 0;
for (int i = 0; i < _loadedFiles.Count; i++)
{
var file = _loadedFiles[i];
try
{
var studyInstanceUid = file.DataSet[DicomTags.StudyInstanceUid].ToString();
var patientId = file.DataSet[DicomTags.PatientId].ToString();
var patientsName = file.DataSet[DicomTags.PatientsName].ToString();
var filename = filenameMap != null ? filenameMap[file.Filename] : file.Filename;
file.Save(filename, DicomWriteOptions.Default);
_dirtyFlags[i] = false;
modifiedInstances.AddInstance(patientId, patientsName, studyInstanceUid);
}
catch (Exception ex)
{
++failureCount;
if (file != null && !string.IsNullOrEmpty(file.Filename))
{
Platform.Log(LogLevel.Warn, ex, "An exception was encountered while trying to update the file \'{0}\'.", file.Filename);
}
else
{
Platform.Log(LogLevel.Warn, ex, "An unexpected error was encountered while trying to update a file.");
}
}
}
if (failureCount > 0)
{
Host.DesktopWindow.ShowMessageBox(SR.MessageErrorUpdatingSomeFiles, MessageBoxActions.Ok);
}
AuditHelper.LogUpdateInstances(new string[0], modifiedInstances, EventSource.CurrentUser, EventResult.Success);
return(true);
}
public override StudyItemList Query(QueryParameters queryParams, IApplicationEntity targetServer)
{
Platform.CheckForNullReference(queryParams, "queryParams");
Platform.CheckForNullReference(targetServer, "targetServer");
var selectedServer = targetServer.ToServiceNode();
//.NET strings are unicode, therefore, so is all the query data.
const string utf8 = "ISO_IR 192";
var requestCollection = new DicomAttributeCollection {
SpecificCharacterSet = utf8
};
requestCollection[DicomTags.SpecificCharacterSet].SetStringValue(utf8);
requestCollection[DicomTags.QueryRetrieveLevel].SetStringValue("STUDY");
requestCollection[DicomTags.StudyInstanceUid].SetStringValue("");
requestCollection[DicomTags.PatientId].SetStringValue(queryParams["PatientId"]);
requestCollection[DicomTags.AccessionNumber].SetStringValue(queryParams["AccessionNumber"]);
requestCollection[DicomTags.PatientsName].SetStringValue(queryParams["PatientsName"]);
requestCollection[DicomTags.ReferringPhysiciansName].SetStringValue(queryParams["ReferringPhysiciansName"]);
requestCollection[DicomTags.StudyDate].SetStringValue(queryParams["StudyDate"]);
requestCollection[DicomTags.StudyTime].SetStringValue("");
requestCollection[DicomTags.StudyDescription].SetStringValue(queryParams["StudyDescription"]);
requestCollection[DicomTags.PatientsBirthDate].SetStringValue("");
requestCollection[DicomTags.ModalitiesInStudy].SetStringValue(queryParams["ModalitiesInStudy"]);
requestCollection[DicomTags.NumberOfStudyRelatedInstances].SetStringValue("");
requestCollection[DicomTags.InstanceAvailability].SetEmptyValue(); // must not be included in request
requestCollection[DicomTags.PatientSpeciesDescription].SetStringValue(GetString(queryParams, "PatientSpeciesDescription"));
var codeValue = GetString(queryParams, "PatientSpeciesCodeSequenceCodeValue");
var codeMeaning = GetString(queryParams, "PatientSpeciesCodeSequenceCodeMeaning");
if (codeValue != null || codeMeaning != null)
{
var codeSequenceMacro = new CodeSequenceMacro
{
CodingSchemeDesignator = "",
CodeValue = codeValue,
CodeMeaning = codeMeaning
};
requestCollection[DicomTags.PatientSpeciesCodeSequence].AddSequenceItem(codeSequenceMacro.DicomSequenceItem);
}
requestCollection[DicomTags.PatientBreedDescription].SetStringValue(GetString(queryParams, "PatientBreedDescription"));
codeValue = GetString(queryParams, "PatientBreedCodeSequenceCodeValue");
codeMeaning = GetString(queryParams, "PatientBreedCodeSequenceCodeMeaning");
if (codeValue != null || codeMeaning != null)
{
var codeSequenceMacro = new CodeSequenceMacro
{
CodingSchemeDesignator = "",
CodeValue = codeValue,
CodeMeaning = codeMeaning
};
requestCollection[DicomTags.PatientBreedCodeSequence].AddSequenceItem(codeSequenceMacro.DicomSequenceItem);
}
requestCollection[DicomTags.ResponsiblePerson].SetStringValue(GetString(queryParams, "ResponsiblePerson"));
requestCollection[DicomTags.ResponsiblePersonRole].SetStringValue("");
requestCollection[DicomTags.ResponsibleOrganization].SetStringValue(GetString(queryParams, "ResponsibleOrganization"));
IList <DicomAttributeCollection> results = Query(selectedServer, requestCollection);
StudyItemList studyItemList = new StudyItemList();
foreach (DicomAttributeCollection result in results)
{
StudyItem item = new StudyItem(result[DicomTags.StudyInstanceUid].GetString(0, ""), selectedServer);
//TODO: add DicomField attributes to the StudyItem class (implement typeconverter for PersonName class).
item.PatientsBirthDate = result[DicomTags.PatientsBirthDate].GetString(0, "");
item.AccessionNumber = result[DicomTags.AccessionNumber].GetString(0, "");
item.StudyDescription = result[DicomTags.StudyDescription].GetString(0, "");
item.StudyDate = result[DicomTags.StudyDate].GetString(0, "");
item.StudyTime = result[DicomTags.StudyTime].GetString(0, "");
item.PatientId = result[DicomTags.PatientId].GetString(0, "");
item.PatientsName = new PersonName(result[DicomTags.PatientsName].GetString(0, ""));
item.ReferringPhysiciansName = new PersonName(result[DicomTags.ReferringPhysiciansName].GetString(0, ""));
item.ModalitiesInStudy = DicomStringHelper.GetStringArray(result[DicomTags.ModalitiesInStudy].ToString());
DicomAttribute attribute = result[DicomTags.NumberOfStudyRelatedInstances];
if (!attribute.IsEmpty && !attribute.IsNull)
{
item.NumberOfStudyRelatedInstances = attribute.GetInt32(0, 0);
}
item.SpecificCharacterSet = result.SpecificCharacterSet;
item.InstanceAvailability = result[DicomTags.InstanceAvailability].GetString(0, "");
if (String.IsNullOrEmpty(item.InstanceAvailability))
{
item.InstanceAvailability = "ONLINE";
}
item.PatientSpeciesDescription = result[DicomTags.PatientSpeciesDescription].GetString(0, "");
var patientSpeciesCodeSequence = result[DicomTags.PatientSpeciesCodeSequence];
if (!patientSpeciesCodeSequence.IsNull && patientSpeciesCodeSequence.Count > 0)
{
var codeSequenceMacro = new CodeSequenceMacro(((DicomSequenceItem[])result[DicomTags.PatientSpeciesCodeSequence].Values)[0]);
item.PatientSpeciesCodeSequenceCodingSchemeDesignator = codeSequenceMacro.CodingSchemeDesignator;
item.PatientSpeciesCodeSequenceCodeValue = codeSequenceMacro.CodeValue;
item.PatientSpeciesCodeSequenceCodeMeaning = codeSequenceMacro.CodeMeaning;
}
item.PatientBreedDescription = result[DicomTags.PatientBreedDescription].GetString(0, "");
var patientBreedCodeSequence = result[DicomTags.PatientBreedCodeSequence];
if (!patientBreedCodeSequence.IsNull && patientBreedCodeSequence.Count > 0)
{
var codeSequenceMacro = new CodeSequenceMacro(((DicomSequenceItem[])result[DicomTags.PatientBreedCodeSequence].Values)[0]);
item.PatientBreedCodeSequenceCodingSchemeDesignator = codeSequenceMacro.CodingSchemeDesignator;
item.PatientBreedCodeSequenceCodeValue = codeSequenceMacro.CodeValue;
item.PatientBreedCodeSequenceCodeMeaning = codeSequenceMacro.CodeMeaning;
}
item.ResponsiblePerson = new PersonName(result[DicomTags.ResponsiblePerson].GetString(0, ""));
item.ResponsiblePersonRole = result[DicomTags.ResponsiblePersonRole].GetString(0, "");
item.ResponsibleOrganization = result[DicomTags.ResponsibleOrganization].GetString(0, "");
studyItemList.Add(item);
}
AuditHelper.LogQueryIssued(selectedServer.AETitle, selectedServer.ScpParameters.HostName, EventSource.CurrentUser,
EventResult.Success, SopClass.StudyRootQueryRetrieveInformationModelFindUid,
requestCollection);
return(studyItemList);
}
public InsertBatchPatientsDataResponse InsertBatchPatients(InsertBatchPatientsDataRequest request)
{
InsertBatchPatientsDataResponse response = new InsertBatchPatientsDataResponse();
if (request.PatientsData != null && request.PatientsData.Count > 0)
{
List <HttpObjectResponse <PatientData> > list = new List <HttpObjectResponse <PatientData> >();
IPatientRepository repo = Factory.GetRepository(request, RepositoryType.Patient);
BulkInsertResult result = (BulkInsertResult)repo.InsertAll(request.PatientsData.Cast <object>().ToList());
if (result != null)
{
if (result.ProcessedIds != null && result.ProcessedIds.Count > 0)
{
// Get the patients that were newly inserted.
List <PatientData> insertedPatients = repo.Select(result.ProcessedIds);
if (insertedPatients != null && insertedPatients.Count > 0)
{
List <string> insertedPatientIds = insertedPatients.Select(p => p.Id).ToList();
#region DataAudit for Patients
AuditHelper.LogDataAudit(request.UserId, MongoCollectionName.Patient.ToString(), insertedPatientIds, Common.DataAuditType.Insert, request.ContractNumber);
#endregion
#region BulkInsert CohortPatientView
List <CohortPatientViewData> cpvList = getMECohortPatientView(insertedPatients);
IPatientRepository cpvRepo = Factory.GetRepository(request, RepositoryType.CohortPatientView);
cpvRepo.InsertAll(cpvList.Cast <object>().ToList());
#endregion
#region BulkInsert EngagePatientSystems.
List <string> processedPatientSystemIds = insertBatchEngagePatientSystem(insertedPatientIds, request);
List <PatientSystemData> insertedPatientSystems = getPatientSystems(processedPatientSystemIds, request);
#region DataAudit for EngagePatientSystems
List <string> insertedPatientSystemIds = insertedPatientSystems.Select(p => p.Id).ToList();
AuditHelper.LogDataAudit(request.UserId, MongoCollectionName.PatientSystem.ToString(), insertedPatientSystemIds, Common.DataAuditType.Insert, request.ContractNumber);
#endregion
insertedPatients.ForEach(r =>
{
string engageValue = string.Empty;
var x = insertedPatientSystems.Where(s => s.PatientId == r.Id).FirstOrDefault();
if (x != null)
{
engageValue = x.Value;
}
list.Add(new HttpObjectResponse <PatientData> {
Code = HttpStatusCode.Created, Body = (PatientData) new PatientData {
Id = r.Id, ExternalRecordId = r.ExternalRecordId, EngagePatientSystemValue = engageValue
}
});
});
#endregion
}
}
result.ErrorMessages.ForEach(e =>
{
list.Add(new HttpObjectResponse <PatientData> {
Code = HttpStatusCode.InternalServerError, Message = e
});
});
}
response.Responses = list;
}
return(response);
}
private TTransfer InitTransferImpl(string submittedResourceFilePath, int?clientMaxBlockSize, bool includeFileHash)
{
const FileSystemTask context = FileSystemTask.DownloadTokenRequest;
TFile fileItem = CreateFileItemImpl(submittedResourceFilePath, false, context);
if (!fileItem.Exists)
{
AuditHelper.AuditRequestedFileNotFound(Auditor, fileItem, context);
string msg = String.Format("Resource [{0}] not found.", submittedResourceFilePath);
throw new VirtualResourceNotFoundException(msg)
{
IsAudited = true
};
}
//get authorization
FileClaims claims = GetFileClaims(fileItem);
if (!claims.AllowReadData)
{
AuditHelper.AuditDeniedOperation(Auditor, context, AuditEvent.FileDataDownloadDenied, fileItem as IVirtualFileItem);
string msg = "Read request for file [{0}] was denied - you are not authorized to read the resource.";
msg = String.Format(msg, submittedResourceFilePath);
throw new ResourceAccessException(msg)
{
IsAudited = true
};
}
//try to get lock
ResourceLockGuard readLock = LockResourceForDownload(fileItem, claims);
if (readLock != null && !readLock.IsLockEnabled)
{
AuditHelper.AuditDeniedOperation(Auditor, context, AuditEvent.FileReadLockDenied, fileItem as IVirtualFileItem);
string msg = "The requested file [{0}] is currently locked and thus cannot be accessed.";
msg = String.Format(msg, submittedResourceFilePath);
throw new ResourceLockedException(msg)
{
IsAudited = true
};
}
//create download token
DownloadToken token = CreateDownloadToken(submittedResourceFilePath, fileItem, clientMaxBlockSize, includeFileHash);
//create expiration job if we have an expiration time
Job <DownloadToken> job = null;
if (token.ExpirationTime.HasValue)
{
job = ScheduleExpiration(token);
}
//create transfer instance
TTransfer transfer = CreateTransfer(submittedResourceFilePath, fileItem, token, claims, readLock, job);
//cache transfer
TransferStore.AddTransfer(transfer);
//audit issued token
AuditHelper.AuditResourceOperation(Auditor, context, AuditEvent.DownloadTokenIssued, fileItem as IVirtualFileItem);
return(transfer);
}
