public async Task <IActionResult> Edit(int id, [Bind("Id,StoreItemName,Completed,Created,DataStoreId")] DataStoreItem dataStoreItem)
{
if (id != dataStoreItem.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(dataStoreItem);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DataStoreItemExists(dataStoreItem.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["DataStoreId"] = new SelectList(_context.DataStore, "Id", "Id", dataStoreItem.DataStoreId);
return(View(dataStoreItem));
}
private void AddOrReplaceCustomxmlPath()
{
CheckIfTypedSettingIsNull();
using (WordprocessingDocument document = WordprocessingDocument.Open(DocumentFilePath, true))
{
string dataStoreItemId = TypedSetting.DataStoreItemId;
CustomXmlPart xmlPart = GetCustomXmlPart(document, dataStoreItemId);
if (xmlPart != null)
{
FileStream fs = new FileStream(TypedSetting.XmlPartFilePath, FileMode.Open);
xmlPart.FeedData(fs);
}
else
{
xmlPart = document.MainDocumentPart.AddCustomXmlPart(CustomXmlPartType.CustomXml);
FileStream fs = new FileStream(TypedSetting.XmlPartFilePath, FileMode.Open);
xmlPart.FeedData(fs);
CustomXmlPropertiesPart xmlPropertiesPart = xmlPart.AddNewPart <CustomXmlPropertiesPart>(TypedSetting.ContentTypeId);
DataStoreItem dataStoreItem = new DataStoreItem();
dataStoreItem.ItemId = dataStoreItemId;
xmlPropertiesPart.DataStoreItem = dataStoreItem;
}
}
}
public SplitUnitDoseViewModel(DataStoreItem d) : base(d)
{
if ((Item as SplitUnitDose).SubDoseFractions != null)
{
string s = (Item as SplitUnitDose).SubDoseFractions;
var a = s.Split('\\');
if (a.Length < 2)
{
NumberOfSubDoses = 1;
DoseSplit t = new DoseSplit(this.Item as SyringeUnitDose);
t.Fraction = 1;
DoseSplits.Clear();
DoseSplits.Add(t);
}
else
{
for (int i = 0; i < a.Length; i++)
{
DoseSplit t = new DoseSplit(this.Item as SyringeUnitDose);
t.Fraction = Convert.ToDouble(a[i]);
DoseSplits.Add(t);
}
}
}
else
{
NumberOfSubDoses = 1;
DoseSplit t = new DoseSplit(this.Item as SyringeUnitDose);
t.Fraction = 1;
DoseSplits.Clear();
DoseSplits.Add(t);
}
}
private static string CreateCustomXmlPropertiesPart(CustomXmlPart customXmlPart)
{
XElement rootElement = customXmlPart.GetXElement();
if (rootElement == null)
{
throw new InvalidOperationException();
}
string storeItemId = "{" + Guid.NewGuid().ToString().ToUpper() + "}";
// Create a ds:dataStoreItem associated with the custom XML part's root element.
var dataStoreItem = new DataStoreItem
{
ItemId = storeItemId,
SchemaReferences = new SchemaReferences()
};
if (rootElement.Name.Namespace != XNamespace.None)
{
dataStoreItem.SchemaReferences.AppendChild(new SchemaReference {
Uri = rootElement.Name.NamespaceName
});
}
// Create the custom XML properties part.
var propertiesPart = customXmlPart.AddNewPart <CustomXmlPropertiesPart>();
propertiesPart.DataStoreItem = dataStoreItem;
propertiesPart.DataStoreItem.Save();
return(storeItemId);
}
public async Task <ActionResult <DataStoreItem> > PostDataStoreItem(DataStoreItem dataStoreItem)
{
_context.DataStoreItem.Add(dataStoreItem);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetDataStoreItem", new { id = dataStoreItem.Id }, dataStoreItem));
}
public async Task <IActionResult> PutDataStoreItem(int id, DataStoreItem dataStoreItem)
{
if (id != dataStoreItem.Id)
{
return(BadRequest());
}
_context.Entry(dataStoreItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DataStoreItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IActionResult Get(int tradeId)
{
DataStoreItem result = default(DataStoreItem);
result = SimpleInMemoryStore.Instance.Data.Where(dataStoreItem => dataStoreItem.Data.TradeId == tradeId).LastOrDefault();
return(new JsonResult(result));
}
protected override async Task Execute(string jobID)
{
DataStoreItem readDsi = await GetRelevantData(jobID);
DataStoreItem outputDsi = await _strategy.Work(readDsi);
await StoreRelevantData(outputDsi);
}
async Task <DataStoreItem> IStrategy.Work(DataStoreItem dsi)
{
Thread.Sleep(100);
dsi.Data = "yo";
return(dsi);
}
public HospitalViewModel(DataStoreItem item)
: base(item)
{
foreach (Ward w in ((Hospital)Item).Wards)
{
Wards.Add(new DataStoreItemViewModel(w));
}
AddNewWardCommand = new RelayCommand(AddWard);
}
async Task <bool> IDataStoreRepository.Write(DataStoreItem item)
{
_sw.Start();
await _distributedCache.SetStringAsync(item.JobID, item.Data, _distributedCacheOptions);
_sw.Stop();
Debug.WriteLine(_sw.Elapsed);
return(true);
}
public BulkDoseViewModel(DataStoreItem item) : base(item)
{
AddUnitDoseCommand = new RelayCommand(MakeUnitDose);
//PreCalTime = DateTime.Now.AddHours(0);
foreach (BaseUnitDose u in ((BaseBulkDose)item).UnitDoses)
{
UnitDoses.Add(u);
}
}
public NucMedPracticeViewModel(DataStoreItem item)
: base(item)
{
_rooms = new ObservableCollection <Room>();
foreach (Room r in ((NucMedPractice)Item).Rooms)
{
_rooms.Add(r);
}
AddRoleCommand = new RelayCommand(AddRole);
AddStudyTypeCommand = new RelayCommand(AddStudyType);
}
public async Task <IActionResult> Create([Bind("Id,StoreItemName,Completed,Created,DataStoreId")] DataStoreItem dataStoreItem)
{
if (ModelState.IsValid)
{
_context.Add(dataStoreItem);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["DataStoreId"] = new SelectList(_context.DataStore, "Id", "Id", dataStoreItem.DataStoreId);
return(View(dataStoreItem));
}
public GeneratorViewModel(DataStoreItem item) : base(item)
{
foreach (Elution l in ((Generator)item).Elutions)
{
Elutions.Add(l);
}
(item as Generator).GeneratorEluting += GeneratorEluting;
(item as Generator).GeneratorEluted += GeneratorEluted;
ElutionDate = DateTime.Now;
ElutionExpiryDate = DateTime.Now.AddDays(1);
AddElutionCommand = new RelayCommand(MakeElution);
}
async Task <DataStoreItem> IDataStoreRepository.Read(string jobID)
{
DataStoreItem dsi = new DataStoreItem();
dsi.JobID = jobID;
_sw.Start();
dsi.Data = await _distributedCache.GetStringAsync(jobID);
_sw.Stop();
Debug.WriteLine(_sw.Elapsed);
return(dsi);
}
public IActionResult Post([FromBody] ManualRejectData value)
{
var correleationId = default(StringValues);
this.Request.Headers.TryGetValue("X-CORRELATION-ID", out correleationId);
DataStoreItem data = new DataStoreItem
{
CorrelationId = correleationId.FirstOrDefault(),
Data = value
};
SimpleInMemoryStore.Instance.Data.Add(data);
return(new JsonResult(data));
}
public ReconstitutedColdKitViewModel(DataStoreItem item) : base(item)
{
InsertQCAnalysisCommand = new RelayCommand(CreatQCAnalysis);
AddQCMeasurementCommand = new RelayCommand(AddQCMeasurement);
if ((Item as ReconstitutedColdKit).QCAnalysis != null)
{
QCExists = true;
}
if ((Item as ReconstitutedColdKit).QCAnalysis != null)
{
foreach (RadiochemicalPurityMeasurement m in ((Item as ReconstitutedColdKit).QCAnalysis.Measurements))
{
Measurements.Add(m);
}
}
}
/// <summary>
/// Generates the content of the custom XML properties part.
/// </summary>
/// <param name="customXmlPropertiesPart">The custom XML properties part1.</param>
private void GenerateCustomXmlPropertiesPartContent(CustomXmlPropertiesPart customXmlPropertiesPart)
{
DataStoreItem dataStoreItem = new DataStoreItem()
{
ItemId = "{" + Guid.NewGuid().ToString().ToUpper() + "}"
};
dataStoreItem.AddNamespaceDeclaration("ds", "http://schemas.openxmlformats.org/officeDocument/2006/customXml");
SchemaReferences schemaReferences = new SchemaReferences();
SchemaReference schemaReference = new SchemaReference()
{
Uri = namespaceUri
};
schemaReferences.Append(schemaReference);
dataStoreItem.Append(schemaReferences);
customXmlPropertiesPart.DataStoreItem = dataStoreItem;
}
public ReconstitutionViewModel(DataStoreItem item) : base(item)
{
if (item is Kit)
{
(item as Kit).ColdKitReconstituted += ColdKitReconstituted;
}
RetrievalCriteria rc = new RetrievalCriteria("Radiopharmaceutical", CriteraType.Equals, (item as Kit).KitDefinition.RadioactiveIngredient);
RetrievalCriteria rc1 = new RetrievalCriteria("ExpiryDate", CriteraType.GreaterThan, DateTime.Now);
RetrievalCriteria rc2 = new RetrievalCriteria("IsDisposed", CriteraType.Equals, false);
List <RetrievalCriteria> rcList = new List <RetrievalCriteria>();
rcList.Add(rc);
rcList.Add(rc1);
rcList.Add(rc2);
_potentialIngredients = DesktopApplication.Librarian.GetItems(typeof(BaseBulkDose), rcList);
SaveDoseCommand = new RelayCommand(SaveBulkDose);
ReadActivityCommand = new RelayCommand(ReadActivity);
BdExpiryDate = DateTime.Now.AddDays(1);
}
public PatientImageViewModel(DataStoreItem item) : base(item)
{
Type t = item.GetType();
foreach (PropertyInfo p in t.GetProperties())
{
ImageProperty ii = new ImageProperty();
ii.PropertyName = Regex.Replace(p.Name, "([a-z](?=[A-Z])|[A-Z](?=[A-Z][a-z]))", "$1 ");
//ii.PropertyName = p.Name;
object o = p.GetValue(item);
if (o != null)
{
ii.PropertyValue = o.ToString();
}
ImageProperties.Add(ii);
}
}
/// <summary>
/// Creates a <see cref="CustomXmlPart" /> with the given root <see cref="XElement" />.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="rootElement">The root element.</param>
/// <returns>The newly created custom XML part.</returns>
public static CustomXmlPart CreateCustomXmlPart(this WordprocessingDocument document, XElement rootElement)
{
if (document == null)
{
throw new ArgumentNullException("document");
}
if (rootElement == null)
{
throw new ArgumentNullException("rootElement");
}
// Create a ds:dataStoreItem associated with the custom XML part's root element.
var dataStoreItem = new DataStoreItem
{
ItemId = "{" + Guid.NewGuid().ToString().ToUpper() + "}",
SchemaReferences = new SchemaReferences()
};
if (rootElement.Name.Namespace != XNamespace.None)
{
dataStoreItem.SchemaReferences.Append(new SchemaReference {
Uri = rootElement.Name.NamespaceName
});
}
// Create the custom XML part.
var customXmlPart = document.MainDocumentPart.AddCustomXmlPart(CustomXmlPartType.CustomXml);
customXmlPart.SetRootElement(rootElement);
// Create the custom XML properties part.
var propertiesPart = customXmlPart.AddNewPart <CustomXmlPropertiesPart>();
propertiesPart.DataStoreItem = dataStoreItem;
propertiesPart.DataStoreItem.Save();
document.Package.Flush();
return(customXmlPart);
}
public static void DumpDataStoreItem(DataStoreItem d)
{
Console.WriteLine("*** " + d.ConcreteType.Name + " Data Dump ***");
foreach (PropertyInfo p in d.GetType().GetProperties())
{
if (p.PropertyType.IsPrimitive || p.PropertyType == typeof(string) || p.PropertyType == typeof(DateTime))
{
if (p.GetValue(d, null) != null)
{
Console.WriteLine(p.Name + ":\t" + p.GetValue(d, null).ToString());
}
else
{
Console.WriteLine(p.Name + ":\t NULL");
}
}
else if (p.PropertyType is IDataStoreItem)
{
//DumpDataStoreItem(d);
}
}
Console.WriteLine("*** End Data Dump ***");
}
public async Task <bool> Save(DataStoreItem item)
{
return(await _dataStoreRepository.Write(item));
}
public RadioactiveInventoryItemViewModel(DataStoreItem item) : base(item)
{
ReadActivityCommand = new RelayCommand(ReadActivity);
_preCalTime = CalibrationDate;
}
public ElutionViewModel(DataStoreItem item) : base(item)
{
}
public static void InsertCustomXmlForPpt(string pptFileName, string customXML)
{
using (PresentationDocument openXmlDoc = PresentationDocument.Open(pptFileName, true))
{
// Create a new custom XML part
int count = openXmlDoc.PresentationPart.Parts.Count();
string customXmlId = string.Format("rId{0}", count + 1);
CustomXmlPart customXmlPart = openXmlDoc.PresentationPart.AddCustomXmlPart(CustomXmlPartType.CustomXml, customXmlId);
using (Stream outputStream = customXmlPart.GetStream())
{
using (StreamWriter ts = new StreamWriter(outputStream))
{
ts.Write(customXML);
}
}
// Add datastore so that the xml will persist after the document is modified
count = customXmlPart.Parts.Count();
CustomXmlPropertiesPart customXmlPropertiesPart = customXmlPart.AddNewPart <CustomXmlPropertiesPart>(string.Format("rId{0}", count + 1));
DataStoreItem dataStoreItem = new DataStoreItem()
{
ItemId = string.Format("{0}", Guid.NewGuid())
};
dataStoreItem.AddNamespaceDeclaration("ds", "http://schemas.openxmlformats.org/officeDocument/2006/customXml");
SchemaReferences schemaReferences = new SchemaReferences();
SchemaReference schemaReference = new SchemaReference()
{
Uri = "http://www.w3.org/2001/XMLSchema"
};
schemaReferences.Append(schemaReference);
dataStoreItem.Append(schemaReferences);
customXmlPropertiesPart.DataStoreItem = dataStoreItem;
// Add the xml to the customer data section of the document
CustomerData customerData = new CustomerData()
{
Id = customXmlId
};
if (openXmlDoc.PresentationPart.Presentation.CustomerDataList != null)
{
// Sequence matters: http://www.schemacentral.com/sc/ooxml/e-p_custDataLst-1.html
if (openXmlDoc.PresentationPart.Presentation.CustomerDataList.Count() > 0)
{
openXmlDoc.PresentationPart.Presentation.CustomerDataList.InsertBefore(customerData, openXmlDoc.PresentationPart.Presentation.CustomerDataList.FirstChild);
}
else
{
openXmlDoc.PresentationPart.Presentation.CustomerDataList.Append(customerData);
}
}
else
{
CustomerDataList customerDataList = new CustomerDataList();
customerDataList.Append(customerData);
// Sequence matters: http://www.schemacentral.com/sc/ooxml/e-p_presentation.html
if (openXmlDoc.PresentationPart.Presentation.Kinsoku != null)
{
openXmlDoc.PresentationPart.Presentation.InsertBefore(customerDataList, openXmlDoc.PresentationPart.Presentation.Kinsoku);
}
else if (openXmlDoc.PresentationPart.Presentation.DefaultTextStyle != null)
{
openXmlDoc.PresentationPart.Presentation.InsertBefore(customerDataList, openXmlDoc.PresentationPart.Presentation.DefaultTextStyle);
}
else if (openXmlDoc.PresentationPart.Presentation.ModificationVerifier != null)
{
openXmlDoc.PresentationPart.Presentation.InsertBefore(customerDataList, openXmlDoc.PresentationPart.Presentation.ModificationVerifier);
}
else if (openXmlDoc.PresentationPart.Presentation.PresentationExtensionList != null)
{
openXmlDoc.PresentationPart.Presentation.InsertBefore(customerDataList, openXmlDoc.PresentationPart.Presentation.PresentationExtensionList);
}
else
{
openXmlDoc.PresentationPart.Presentation.Append(customerDataList);
}
}
}
}
public KitDefinitionViewModel(DataStoreItem item) : base(item)
{
}
public StudyReportViewModel(DataStoreItem item)
: base(item)
{
}
public DoseAdministrationTaskViewModel(DataStoreItem item)
: base(item)
{
}
