public BlockingConstraintModel(BlockingConstraint constraint)
{
Id = constraint.Id;
Index = constraint.Index;
Negated = constraint.Negated;
SelectedMode = constraint.Mode;
Description = constraint.Description;
AllUsers = constraint.AllUsers;
ForEver = constraint.ForEver;
ForTimeInterval = new TimeInterval();
if (constraint.ForPeriodicTimeInterval != null)
{
if (constraint.ForPeriodicTimeInterval.Id != 0)
{
ForPeriodicTimeInterval = new PeriodicTimeIntervalModel(constraint.ForPeriodicTimeInterval, (DateTime)constraint.ForTimeInterval.StartTime.Instant, constraint.ForTimeInterval.EndTime.Instant);
ForPeriodicTimeInterval.IsSet = true;
ForPeriodicTimeInterval.Index = constraint.Index;
}
else
{
ForPeriodicTimeInterval = new PeriodicTimeIntervalModel();
}
}
if (constraint.ForPerson != null)
{
if (constraint.ForPerson.Self is PersonGroup)
{
PersonGroup pGroup = (PersonGroup)constraint.ForPerson.Self;
// pGroup.Users.ToList().ForEach(u => ForPersons.Add(new PersonInConstraint(u, pGroup.Id, constraint.Index)));
}
else if (constraint.ForPerson.Self is IndividualPerson)
{
IndividualPerson iPerson = (IndividualPerson)constraint.ForPerson.Self;
ForPersons.Add(new PersonInConstraint(iPerson.Person, iPerson.Id, constraint.Index));
}
}
if (constraint.ForTimeInterval != null)
{
TimeInterval timeInterval = new TimeInterval();
timeInterval = constraint.ForTimeInterval.Self;
timeInterval.StartTime = constraint.ForTimeInterval.StartTime.Self;
timeInterval.EndTime = constraint.ForTimeInterval.EndTime.Self;
ForTimeInterval = timeInterval;
}
else
{
ForTimeInterval = new TimeInterval();
}
}
public BlockingConstraint SaveConstraint(BlockingConstraint constraint)
{
//if (timePeriod != null)
// constraint.TimePeriod = timePeriod;
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <BlockingConstraint> repo = uow.GetRepository <BlockingConstraint>();
repo.Put(constraint);
uow.Commit();
}
return(constraint);
}
public bool DeleteConstraint(BlockingConstraint constraint)
{
Contract.Requires(constraint != null);
Contract.Requires(constraint.Id >= 0);
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <BlockingConstraint> repo = uow.GetRepository <BlockingConstraint>();
constraint = repo.Reload(constraint);
repo.Delete(constraint);
uow.Commit();
}
return(true);
}
public BlockingConstraint UpdateConstraint(BlockingConstraint constraint)
{
Contract.Requires(constraint != null, "provided entity can not be null");
Contract.Requires(constraint.Id >= 0, "provided entity must have a permanent ID");
Contract.Ensures(Contract.Result <BlockingConstraint>() != null && Contract.Result <BlockingConstraint>().Id >= 0, "No entity is persisted!");
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <BlockingConstraint> repo = uow.GetRepository <BlockingConstraint>();
repo.Merge(constraint);
var merged = repo.Get(constraint.Id);
repo.Put(merged);
uow.Commit();
}
return(constraint);
}
