public DependencyConstraintModel(DependencyConstraint constraint)
        {
            Id           = constraint.Id;
            Index        = constraint.Index;
            Negated      = constraint.Negated;
            SelectedMode = constraint.Mode;
            Description  = constraint.Description;

            if (constraint.ForPeriodicTimeInterval != null)
            {
                if (constraint.ForPeriodicTimeInterval.Id != 0)
                {
                    ForPeriodicTimeInterval       = new PeriodicTimeIntervalModel(constraint.ForPeriodicTimeInterval, (DateTime)constraint.ForTimeInterval.StartTime.Instant, (DateTime)constraint.ForTimeInterval.EndTime.Instant);
                    ForPeriodicTimeInterval.IsSet = true;
                    ForPeriodicTimeInterval.Index = constraint.Index;
                }
            }
            else
            {
                ForPeriodicTimeInterval = new PeriodicTimeIntervalModel();
            }

            ResourceObjects = new List <string>();
            ResourceObjects.Add("Single Resource");
            Implicit = constraint.Implicit;
            Quantity = constraint.Quantity;
            QuantityComparisonOperator = constraint.QuantityComparisonOperator;
            ObjectName = constraint.ForResource.Name;
            ObjectId   = constraint.ForResource.Id.ToString();
        }
        public DependencyConstraint SaveConstraint(DependencyConstraint constraint)
        {
            //if(timePeriod != null)
            //    constraint.TimePeriod = timePeriod;

            using (IUnitOfWork uow = this.GetUnitOfWork())
            {
                IRepository <DependencyConstraint> repo = uow.GetRepository <DependencyConstraint>();
                repo.Put(constraint);
                uow.Commit();
            }
            return(constraint);
        }
        public bool DeleteConstraint(DependencyConstraint constraint)
        {
            Contract.Requires(constraint != null);
            Contract.Requires(constraint.Id >= 0);

            using (IUnitOfWork uow = this.GetUnitOfWork())
            {
                IRepository <DependencyConstraint> repo = uow.GetRepository <DependencyConstraint>();
                constraint = repo.Reload(constraint);
                repo.Delete(constraint);
                uow.Commit();
            }
            return(true);
        }
        public DependencyConstraint UpdateConstraint(DependencyConstraint 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 <DependencyConstraint>() != null && Contract.Result <DependencyConstraint>().Id >= 0, "No entity is persisted!");

            using (IUnitOfWork uow = this.GetUnitOfWork())
            {
                IRepository <DependencyConstraint> repo = uow.GetRepository <DependencyConstraint>();
                repo.Merge(constraint);
                var merged = repo.Get(constraint.Id);
                repo.Put(merged);
                uow.Commit();
            }
            return(constraint);
        }