public bool Delete(ObtainingMethod entity)
{
Contract.Requires(entity != null);
Contract.Requires(entity.Id >= 0);
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository<ObtainingMethod> repo = uow.GetRepository<ObtainingMethod>();
entity = repo.Reload(entity);
//relation to DataContainer is managed by the other end
repo.Delete(entity);
uow.Commit();
}
// if any problem was detected during the commit, an exception will be thrown!
return (true);
}
public ObtainingMethod Create(string name, string description)
{
Contract.Requires(!string.IsNullOrWhiteSpace(name));
Contract.Ensures(Contract.Result<ObtainingMethod>() != null && Contract.Result<ObtainingMethod>().Id >= 0);
ObtainingMethod u = new ObtainingMethod()
{
Name = name,
Description = description,
};
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository<ObtainingMethod> repo = uow.GetRepository<ObtainingMethod>();
repo.Put(u);
uow.Commit();
}
return (u);
}
public ObtainingMethod Update(ObtainingMethod entity)
{
Contract.Requires(entity != null, "provided entity can not be null");
Contract.Requires(entity.Id >= 0, "provided entity must have a permant ID");
Contract.Ensures(Contract.Result<ObtainingMethod>() != null && Contract.Result<ObtainingMethod>().Id >= 0, "No entity is persisted!");
using (IUnitOfWork uow = entity.GetUnitOfWork())
{
IRepository<ObtainingMethod> repo = uow.GetRepository<ObtainingMethod>();
repo.Put(entity); // Merge is required here!!!!
uow.Commit();
}
return (entity);
}
/// <summary>
/// This method creates a variable value and returns it without persisting the object in the database. Usually the returned variable value should be added to a data tuple which in turn is belonging to a data set version.
/// A value is a compound object holding information about a single event (sampling). The event can be a(n) measurement, observation, estimation, simulation, or computation of a feature of an entity.
/// The value can be a assigned to a variable or a parameter based on the design of the data structure.
/// </summary>
/// <param name="value">The result of the event which can be a(n) measurement, observation, estimation, simulation, or computation</param>
/// <param name="note">A free format, but short, description about the value</param>
/// <param name="samplingTime">The exact time of the start of the event. It shows when the sampling is started.</param>
/// <param name="resultTime">The sampling, or the processing may take time (like in the computation or simulation cases), also some devices/ sensors have a response time. The parameter captures the time when the result (value) is ready.
/// The result time and its difference to sampling time are important for some analyses.
/// </param>
/// <param name="obtainingMethod">Determines how the values is obtained, which is one of the measurement, observation, estimation, simulation, or computation cases.</param>
/// <param name="variableId">The identifier of the variable that the value is belonging to.</param>
/// <param name="parameterValues">If the variable has parameters attached, the parameter values are passed alongside, so that the method links them to their corresponding variable value using <paramref name="variableId"/>.</param>
/// <returns>A transient object of type <seealso cref="VariableValue"/>.</returns>
public VariableValue CreateVariableValue(string value, string note, DateTime samplingTime, DateTime resultTime, ObtainingMethod obtainingMethod, Int64 variableId, ICollection<ParameterValue> parameterValues)
{
Contract.Requires(!string.IsNullOrWhiteSpace(value));
Contract.Requires(variableId > 0);
Contract.Ensures(Contract.Result<VariableValue>() != null);
VariableValue e = new VariableValue()
{
Value = value,
Note = note,
SamplingTime = samplingTime,
ResultTime = resultTime,
ObtainingMethod = obtainingMethod,
VariableId = variableId,
ParameterValues = new List<ParameterValue>(parameterValues),
};
//using (IUnitOfWork uow = this.GetUnitOfWork())
//{
// IRepository<VariableValue> repo = uow.GetRepository<VariableValue>();
// repo.Put(e);
// uow.Commit();
//}
return (e);
}
/// <summary>
/// Creates a parameter value similar to <see cref="CreateVariableValue"/>.
/// </summary>
/// <param name="value"></param>
/// <param name="note"></param>
/// <param name="samplingTime"></param>
/// <param name="resultTime"></param>
/// <param name="obtainingMethod"></param>
/// <param name="parameterId"></param>
/// <returns>A transient object of type <seealso cref="ParameterValue"/>.</returns>
public ParameterValue CreateParameterValue(string value, string note, DateTime samplingTime, DateTime resultTime, ObtainingMethod obtainingMethod, Int64 parameterId)
{
Contract.Requires(!string.IsNullOrWhiteSpace(value));
Contract.Requires(parameterId > 0);
Contract.Ensures(Contract.Result<ParameterValue>() != null);
ParameterValue e = new ParameterValue()
{
Value = value,
Note = note,
SamplingTime = samplingTime,
ResultTime = resultTime,
ObtainingMethod = obtainingMethod,
ParameterId = parameterId,
};
//using (IUnitOfWork uow = this.GetUnitOfWork())
//{
// IRepository<ParameterValue> repo = uow.GetRepository<ParameterValue>();
// repo.Put(e);
// uow.Commit();
//}
return (e);
}
/// <summary>
/// An extended property is a custom property that is assigned to a dataset version in addition to the predefined properties. Then each dataset version owner/ accessor
/// can provide a value for the attached properties.
/// </summary>
/// <param name="extendedPropertyId">The identifier of the extended property.</param>
/// <param name="value">The value to be assigned to the extended property of the dataset version.</param>
/// <param name="note"><see cref="DataValue"/></param>
/// <param name="samplingTime"><see cref="DataValue"/></param>
/// <param name="resultTime"><see cref="DataValue"/></param>
/// <param name="obtainingMethod"><see cref="DataValue"/></param>
/// <param name="datasetVersion">The dataset version receiving the property value</param>
/// <returns>The extended property value linked to its <see cref="ExtendedProperty"/> and the <see cref="DatasetVersion"/></returns>
public ExtendedPropertyValue CreateExtendedPropertyValue(Int64 extendedPropertyId, string value, string note, DateTime samplingTime, DateTime resultTime, ObtainingMethod obtainingMethod,
DatasetVersion datasetVersion)
{
Contract.Requires(!string.IsNullOrWhiteSpace(value));
Contract.Requires(extendedPropertyId > 0);
Contract.Requires(datasetVersion != null);
Contract.Ensures(Contract.Result<ExtendedPropertyValue>() != null);
ExtendedPropertyValue e = new ExtendedPropertyValue()
{
Value = value,
Note = note,
SamplingTime = samplingTime,
ResultTime = resultTime,
ObtainingMethod = obtainingMethod,
ExtendedPropertyId = extendedPropertyId,
DatasetVersion = datasetVersion, // subject to delete
};
e.DatasetVersion.ExtendedPropertyValues.Add(e);
//using (IUnitOfWork uow = this.GetUnitOfWork())
//{
// IRepository<ExtendedPropertyValue> repo = uow.GetRepository<ExtendedPropertyValue>();
// repo.Put(e);
// uow.Commit();
//}
return (e);
}
/// <summary>
/// An amendment is like a variable value that is added to a data tuple. The difference is that the amendment does not need to be defined in the dataset's structure
/// and also not all the data tuples need to have the same amendments.
/// This method creates and amendment object, attaches it to the data tuple but does <b>NOT</b> persist it.
/// </summary>
/// <param name="value"><see cref="DataValue"/></param>
/// <param name="note"><see cref="DataValue"/></param>
/// <param name="samplingTime"><see cref="DataValue"/></param>
/// <param name="resultTime"><see cref="DataValue"/></param>
/// <param name="obtainingMethod"><see cref="DataValue"/></param>
/// <param name="parameterId">The identifier of the parameter that the amendment will be linked to. needs more clarification</param>
/// <param name="tuple">The data tuple receiving the amendment.ku</param>
/// <returns></returns>
public Amendment CreateAmendment(string value, string note, DateTime samplingTime, DateTime resultTime, ObtainingMethod obtainingMethod, Int64 parameterId, DataTuple tuple)
{
Contract.Requires(!string.IsNullOrWhiteSpace(value));
Contract.Requires(parameterId > 0);
Contract.Requires(tuple != null);
Contract.Ensures(Contract.Result<Amendment>() != null);
Amendment e = new Amendment()
{
Value = value,
Note = note,
SamplingTime = samplingTime,
ResultTime = resultTime,
ObtainingMethod = obtainingMethod,
ParameterId = parameterId,
Tuple = tuple,
};
//using (IUnitOfWork uow = this.GetUnitOfWork())
//{
// IRepository<Amendment> repo = uow.GetRepository<Amendment>();
// repo.Put(e);
// uow.Commit();
//}
return (e);
}
