public void UpdateValue(EAV.Store.IStoreValue value)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
EAVStoreClient.Value dbValue = ctx.Values.SingleOrDefault(it => it.Instance_ID == value.InstanceID && it.Attribute_ID == value.AttributeID);
if (dbValue != null)
{
if (dbValue.Raw_Value != value.RawValue)
{
dbValue.Raw_Value = value.RawValue;
}
if (dbValue.Unit_ID != value.UnitID)
{
dbValue.Unit_ID = value.UnitID;
}
ctx.SaveChanges();
}
else
{
throw (new Exception(String.Format("Unable to retrieve value for instance ID {0}, attribute ID {1}.", value.InstanceID, value.AttributeID)));
}
}
}
public EAV.Store.IStoreInstance CreateChildInstance(EAV.Store.IStoreInstance instance, int containerID, int parentInstanceID)
{
if (instance == null)
{
return(null);
}
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
Instance dbInstance = new Instance(instance);
Instance dbParentInstance = ctx.Instances.SingleOrDefault(it => it.Instance_ID == parentInstanceID);
// TODO: Error if dbParentInstance is null
dbInstance.Subject_ID = dbParentInstance.Subject_ID;
dbInstance.Container_ID = containerID;
dbInstance.Parent_Instance_ID = parentInstanceID;
ctx.Instances.Add(dbInstance);
ctx.SaveChanges();
return((EAVStoreLibrary.StoreInstance)dbInstance);
}
}
public EAV.Store.IStoreContainer CreateChildContainer(EAV.Store.IStoreContainer container, int parentContainerID)
{
if (container == null)
{
return(null);
}
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
Container dbContainer = new Container(container);
Container dbParentContainer = ctx.Containers.SingleOrDefault(it => it.Container_ID == parentContainerID);
if (dbContainer == null)
{
throw (new InvalidOperationException("Unable to locate parent container."));
}
dbContainer.Context_ID = dbParentContainer.Context_ID;
dbContainer.Parent_Container_ID = parentContainerID;
ctx.Containers.Add(dbContainer);
ctx.SaveChanges();
return((EAVStoreLibrary.StoreContainer)dbContainer);
}
}
public void UpdateContext(EAV.Store.IStoreContext context)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
EAVStoreClient.Context dbContext = ctx.Contexts.SingleOrDefault(it => it.Context_ID == context.ContextID);
if (dbContext != null)
{
if (dbContext.Name != context.Name)
{
dbContext.Name = context.Name;
}
if (dbContext.Data_Name != context.DataName)
{
dbContext.Data_Name = context.DataName;
}
if (dbContext.Display_Text != context.DisplayText)
{
dbContext.Display_Text = context.DisplayText;
}
ctx.SaveChanges();
}
else
{
throw (new Exception(String.Format("Unable to retrieve context ID {0}.", context.ContextID)));
}
}
}
public void UpdateAttributeUnits(int attributeID, IEnumerable <EAV.Store.IStoreUnit> units)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
var dbAttribute = ctx.Attributes.SingleOrDefault(it => it.Attribute_ID == attributeID);
if (dbAttribute != null)
{
var unitsToDelete = dbAttribute.Units.GroupJoin(units, left => left.Unit_ID, right => right.UnitID.GetValueOrDefault(), (left, right) => new { UnitToDelete = left, SentinelUnit = right.FirstOrDefault() }).Where(it => it.SentinelUnit == null).Select(it => it.UnitToDelete.Unit_ID);
var unitsToAdd = units.GroupJoin(dbAttribute.Units, left => left.UnitID.GetValueOrDefault(), right => right.Unit_ID, (left, right) => new { UnitToAdd = left, SentinelUnit = right.FirstOrDefault() }).Where(it => it.SentinelUnit == null && it.UnitToAdd.UnitID != 0).Select(it => it.UnitToAdd.UnitID.GetValueOrDefault());
foreach (int id in unitsToDelete)
{
dbAttribute.Units.Remove(dbAttribute.Units.Single(it => it.Unit_ID == id));
}
foreach (int id in unitsToAdd)
{
dbAttribute.Units.Add(ctx.Units.Single(it => it.Unit_ID == id));
}
ctx.SaveChanges();
}
else
{
throw(new Exception(String.Format("Unable to retrieve attribute ID {0}.", attributeID)));
}
}
}
public void UpdateUnit(EAV.Store.IStoreUnit aUnit)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
EAVStoreClient.Unit dbUnit = ctx.Units.SingleOrDefault(it => it.Unit_ID == aUnit.UnitID);
if (dbUnit != null)
{
if (dbUnit.Singular_Name != aUnit.SingularName)
{
dbUnit.Singular_Name = aUnit.SingularName;
}
if (dbUnit.Singular_Abbreviation != aUnit.SingularAbbreviation)
{
dbUnit.Singular_Abbreviation = aUnit.SingularAbbreviation;
}
if (dbUnit.Plural_Name != aUnit.PluralName)
{
dbUnit.Plural_Name = aUnit.PluralName;
}
if (dbUnit.Plural_Abbreviation != aUnit.PluralAbbreviation)
{
dbUnit.Plural_Abbreviation = aUnit.PluralAbbreviation;
}
if (dbUnit.Symbol != aUnit.Symbol)
{
dbUnit.Symbol = aUnit.Symbol;
}
if (dbUnit.Display_Text != aUnit.DisplayText)
{
dbUnit.Display_Text = aUnit.DisplayText;
}
if (dbUnit.Curated != aUnit.Curated)
{
dbUnit.Curated = aUnit.Curated;
}
ctx.SaveChanges();
}
else
{
throw (new Exception(String.Format("Unable to retrieve Unit ID {0}.", aUnit.UnitID)));
}
}
}
public void UpdateAttribute(EAV.Store.IStoreAttribute attribute)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
EAVStoreClient.Attribute dbAttribute = ctx.Attributes.SingleOrDefault(it => it.Attribute_ID == attribute.AttributeID);
if (dbAttribute != null)
{
if (dbAttribute.Name != attribute.Name)
{
dbAttribute.Name = attribute.Name;
}
if (dbAttribute.Data_Name != attribute.DataName)
{
dbAttribute.Data_Name = attribute.DataName;
}
if (dbAttribute.Display_Text != attribute.DisplayText)
{
dbAttribute.Display_Text = attribute.DisplayText;
}
if (dbAttribute.Data_Type.Name != attribute.DataType.ToString())
{
dbAttribute.Data_Type = ctx.Data_Type.Single(it => it.Name == attribute.DataType.ToString());
}
if (dbAttribute.Sequence != attribute.Sequence)
{
dbAttribute.Sequence = attribute.Sequence;
}
if (dbAttribute.Is_Key != attribute.IsKey)
{
dbAttribute.Is_Key = attribute.IsKey;
}
if (dbAttribute.Variable_Units != attribute.VariableUnits)
{
dbAttribute.Variable_Units = attribute.VariableUnits;
}
ctx.SaveChanges();
}
else
{
throw (new Exception(String.Format("Unable to retrieve attribute ID {0}.", attribute.AttributeID)));
}
}
}
public void DeleteInstance(int instanceID)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
var dbInstance = ctx.Instances.SingleOrDefault(it => it.Instance_ID == instanceID);
if (dbInstance != null)
{
ctx.Instances.Remove(dbInstance);
ctx.SaveChanges();
}
}
}
public void DeleteContainer(int containerID)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
var dbContainer = ctx.Containers.SingleOrDefault(it => it.Container_ID == containerID);
if (dbContainer != null)
{
ctx.Containers.Remove(dbContainer);
ctx.SaveChanges();
}
}
}
public void DeleteEntity(int entityID)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
var dbEntity = ctx.Entities.SingleOrDefault(it => it.Entity_ID == entityID);
if (dbEntity != null)
{
ctx.Entities.Remove(dbEntity);
ctx.SaveChanges();
}
}
}
public void DeleteValue(int attributeID, int instanceID)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
var dbValue = ctx.Values.SingleOrDefault(it => it.Instance_ID == instanceID && it.Attribute_ID == attributeID);
if (dbValue != null)
{
ctx.Values.Remove(dbValue);
ctx.SaveChanges();
}
}
}
public void DeleteSubject(int subjectID)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
var dbSubject = ctx.Subjects.SingleOrDefault(it => it.Subject_ID == subjectID);
if (dbSubject != null)
{
ctx.Subjects.Remove(dbSubject);
ctx.SaveChanges();
}
}
}
public void DeleteUnit(int unitID)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
var dbUnit = ctx.Units.SingleOrDefault(it => it.Unit_ID == unitID);
if (dbUnit != null)
{
ctx.Units.Remove(dbUnit);
ctx.SaveChanges();
}
}
}
public void DeleteAttribute(int attributeID)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
var dbAttribute = ctx.Attributes.SingleOrDefault(it => it.Attribute_ID == attributeID);
if (dbAttribute != null)
{
// TODO: Right way to do this?
dbAttribute.Units.Clear();
ctx.Attributes.Remove(dbAttribute);
ctx.SaveChanges();
}
}
}
public EAV.Store.IStoreContainer CreateRootContainer(EAV.Store.IStoreContainer container, int contextID)
{
if (container == null)
{
return(null);
}
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
Container dbContainer = new Container(container);
dbContainer.Context_ID = contextID;
ctx.Containers.Add(dbContainer);
ctx.SaveChanges();
return((EAVStoreLibrary.StoreContainer)dbContainer);
}
}
public EAV.Store.IStoreUnit CreateUnit(EAV.Store.IStoreUnit aUnit)
{
if (aUnit == null)
{
return(null);
}
// TODO: Need to check that at least one string property has a non-empty value?
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
Unit dbUnit = new Unit(aUnit);
ctx.Units.Add(dbUnit);
ctx.SaveChanges();
return((EAVStoreLibrary.StoreUnit)dbUnit);
}
}
public void UpdateContainer(EAV.Store.IStoreContainer container)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
EAVStoreClient.Container dbContainer = ctx.Containers.SingleOrDefault(it => it.Container_ID == container.ContainerID);
if (dbContainer != null)
{
if (dbContainer.Name != container.Name)
{
dbContainer.Name = container.Name;
}
if (dbContainer.Data_Name != container.DataName)
{
dbContainer.Data_Name = container.DataName;
}
if (dbContainer.Display_Text != container.DisplayText)
{
dbContainer.Display_Text = container.DisplayText;
}
if (dbContainer.Is_Repeating != container.IsRepeating)
{
dbContainer.Is_Repeating = container.IsRepeating;
}
if (dbContainer.Sequence != container.Sequence)
{
dbContainer.Sequence = container.Sequence;
}
ctx.SaveChanges();
}
else
{
throw (new Exception(String.Format("Unable to retrieve container ID {0}.", container.ContainerID)));
}
}
}
public EAV.Store.IStoreInstance CreateRootInstance(EAV.Store.IStoreInstance instance, int containerID, int subjectID)
{
if (instance == null)
{
return(null);
}
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
Instance dbInstance = new Instance(instance);
dbInstance.Subject_ID = subjectID;
dbInstance.Container_ID = containerID;
ctx.Instances.Add(dbInstance);
ctx.SaveChanges();
return((EAVStoreLibrary.StoreInstance)dbInstance);
}
}
public EAV.Store.IStoreValue CreateValue(EAV.Store.IStoreValue value, int instanceID, int attributeID)
{
if (value == null)
{
return(null);
}
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
Value dbValue = new Value(value);
dbValue.Instance_ID = instanceID;
dbValue.Attribute_ID = attributeID;
ctx.Values.Add(dbValue);
ctx.SaveChanges();
return((EAVStoreLibrary.StoreValue)dbValue);
}
}
public void UpdateEntity(EAV.Store.IStoreEntity anEntity)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
EAVStoreClient.Entity dbEntity = ctx.Entities.SingleOrDefault(it => it.Entity_ID == anEntity.EntityID);
if (dbEntity != null)
{
if (dbEntity.Descriptor != anEntity.Descriptor)
{
dbEntity.Descriptor = anEntity.Descriptor;
}
ctx.SaveChanges();
}
else
{
throw (new Exception(String.Format("Unable to retrieve entity ID {0}.", anEntity.EntityID)));
}
}
}
public EAV.Store.IStoreAttribute CreateAttribute(EAV.Store.IStoreAttribute attribute, int containerID)
{
if (attribute == null)
{
return(null);
}
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
Attribute dbAttribute = new Attribute(attribute);
dbAttribute.Container_ID = containerID;
dbAttribute.Data_Type = ctx.LookupDataType(attribute.DataType);
ctx.Attributes.Add(dbAttribute);
ctx.SaveChanges();
return((EAVStoreLibrary.StoreAttribute)dbAttribute);
}
}
public void UpdateSubject(EAV.Store.IStoreSubject subject)
{
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
EAVStoreClient.Subject dbSubject = ctx.Subjects.SingleOrDefault(it => it.Subject_ID == subject.SubjectID);
if (dbSubject != null)
{
if (dbSubject.Identifier != subject.Identifier)
{
dbSubject.Identifier = subject.Identifier;
}
ctx.SaveChanges();
}
else
{
throw (new Exception(String.Format("Unable to retrieve subject ID {0}.", subject.SubjectID)));
}
}
}
public EAV.Store.IStoreSubject CreateSubject(EAV.Store.IStoreSubject subject, int contextID, int entityID)
{
if (subject == null)
{
return(null);
}
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
Subject dbSubject = new Subject(subject);
dbSubject.Context_ID = contextID;
dbSubject.Entity_ID = entityID;
ctx.Subjects.Add(dbSubject);
ctx.SaveChanges();
return((EAVStoreLibrary.StoreSubject)dbSubject);
}
}
public EAV.Store.IStoreEntity CreateEntity(EAV.Store.IStoreEntity anEntity)
{
if (anEntity == null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(anEntity.Descriptor))
{
throw (new InvalidOperationException("Property 'Name' for parameter 'entity' may not be null or empty."));
}
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
Entity dbEntity = new Entity(anEntity);
ctx.Entities.Add(dbEntity);
ctx.SaveChanges();
return((EAVStoreLibrary.StoreEntity)dbEntity);
}
}
public EAV.Store.IStoreContext CreateContext(EAV.Store.IStoreContext context)
{
if (context == null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(context.Name))
{
throw (new InvalidOperationException("Property 'Name' for parameter 'context' may not be null or empty."));
}
using (EAVStoreClient.MicroEAVContext ctx = new MicroEAVContext())
{
Context dbContext = new Context(context);
ctx.Contexts.Add(dbContext);
ctx.SaveChanges();
return((EAVStoreLibrary.StoreContext)dbContext);
}
}