public bool CheckCommoditySupplierIsUsed(CommoditySupplier commoditySupplier, EntityStatus intendedStatus)
        {
            if (intendedStatus == EntityStatus.Inactive)
            {
                if ( _ctx.tblCommodityOwner.Any(n => n.CostCentreId == commoditySupplier.Id && n.IM_Status == (int) EntityStatus.Active))
                    return true;
                if (_ctx.tblCommodityProducer.Any(n => n.CostCentreId == commoditySupplier.Id && n.IM_Status == (int)EntityStatus.Active))
                    return true;
            }
            if (intendedStatus == EntityStatus.Deleted)
            {
                if (_ctx.tblCommodityOwner.Any(n => n.CostCentreId == commoditySupplier.Id &&
                                                    (n.IM_Status == (int) EntityStatus.Active ||
                                                     n.IM_Status == (int) EntityStatus.Inactive)
                    ))
                    return true;
                if (_ctx.tblCommodityProducer.Any(n => n.CostCentreId == commoditySupplier.Id &&
                                                       (n.IM_Status == (int) EntityStatus.Active ||
                                                        n.IM_Status == (int) EntityStatus.Inactive)
                    )) return true;
            }
            if (_ctx.tblSourcingDocument.Any(n => n.DocumentOnBehalfOfCostCentreId == commoditySupplier.Id))
                return true;

            return false;
        }

        public IPacket ReadPacket(IMinecraftDataReader reader)
        {
            EntityID = reader.ReadInt();
            Status = (EntityStatus) reader.ReadSByte();

            return this;
        }

 public MasterEntity(Guid id, DateTime dateCreated, DateTime dateLastUpdated, EntityStatus status)
     : this(id)
 {
     _DateCreated = dateCreated;
     _DateLastUpdated = dateLastUpdated;
     _Status = status;
 }

 public ChangeStatusForm(string entityName, string entityType, EntityStatus status)
 {
     InitializeComponent();
     lblMessage.Text = string.Format(status == EntityStatus.Active ? DisableFormat : EnableFormat,
                                     entityType ?? Unknown,
                                     entityName ?? Unknown);
     Width = lblMessage.Width + 72;
 }

        public static Address GetAddressesOrDomain(this IAddressManager client, MailAddress address, EntityStatus? status)
        {
            if (address == null)
            {
                throw new ArgumentNullException("address");
            }

            return client.GetAddressesOrDomain(address.Address, status);
        }

        public void Delete()
        {
            if ( this.EntityStatus == EntityStatus.New )
                throw new InvalidOperationException();

            this.entityStatus = EntityStatus.Deleted;
            Client.Current.DeleteEntity( this );

            this.OnPropertyChanged( "EntityStatus" );
        }

 public Domain[] GetDomains(string[] domainNames, EntityStatus? status)
 {
     try
     {
         return Store.Domains.Get(domainNames, status);
     }
     catch (Exception ex)
     {
         throw CreateFault("GetDomains", ex);
     }
 }

 public static CertainValueCertainProductDiscount.CertainValueCertainProductDiscountItem MakeItem(decimal value = 100, int effectiveDateOffset = -1,
     int endDateOffset = 1, EntityStatus status = EntityStatus.Active)
 {
     return new CertainValueCertainProductDiscount.CertainValueCertainProductDiscountItem(Guid.NewGuid())
     {
         EffectiveDate = DateTime.Now.AddDays(effectiveDateOffset),
         EndDate = DateTime.Now.AddDays(endDateOffset),
         CertainValue = value,
         IsActive = status,
         _Status = status
     };
 }

 public static CertainValueCertainProductDiscount MakeDiscount(decimal value = 100, int effectiveDateOffset = -1,
     int endDateOffset = 1, EntityStatus status = EntityStatus.Active)
 {
     return new CertainValueCertainProductDiscount(Guid.NewGuid())
     {
         CertainValueCertainProductDiscountItems =
             new List<CertainValueCertainProductDiscount.CertainValueCertainProductDiscountItem>
             {
                 MakeItem(value, effectiveDateOffset, endDateOffset, status)
             }
     };
 }

        public IEntityPage<IPost> GetPostPage(int? tagId, int? seriesId, EntityStatus status, int skipCount, int takeCount)
        {
            //Get total count
            var postCount = AppCache.PostCounts.GetOrAddCount(() => GetPostCounts(tagId, seriesId, status)
                , tagId, seriesId, status);

            //Get posts for the requested page
            var sql = GetPostsPageSql(false, tagId, seriesId, status, skipCount, takeCount);
            var posts = this.dbContext.Query<Post, Series>(sql).Select(p => SetupPostAfterLoad(p, false));

            return new EntityPage<IPost>(skipCount, takeCount, postCount, posts);
        }

 public static IEnumerable<Domain> Get(this Table<Domain> table, string[] domains, EntityStatus status)
 {
     if (domains.IsNullOrEmpty())
     {
         throw new ArgumentException("value was null or empty", "domains");
     }
     //
     // We cannot precompile this (throws at runtime) because domains.Length can change at runtime
     //
     return from domain in table.GetDB().Domains
            where domains.Contains(domain.Name) && domain.Status == status
            select domain;
 }

 public static IEnumerable<Address> Get(this Table<Address> table, string[] emailAddresses, EntityStatus? status)
 {
     if (emailAddresses.IsNullOrEmpty())
     {
         throw new ArgumentException("value was null or empty", "emailAddresses");
     }
     //
     // We cannot precompile this (throws at runtime) because emailAddresses.Length can change at runtime
     //
     return from address in table.GetDB().Addresses
            where emailAddresses.Contains(address.EmailAddress) && address.Status == status
            select address;
 }

        public static Domain GetDomain(this DomainManagerClient client, string domainName, EntityStatus? status)
        {
            if (string.IsNullOrEmpty(domainName))
            {
                throw new ArgumentException("value was null or empty", "domainName");
            }

            Domain[] domains = client.GetDomains(new string[] { domainName }, status);
            if (domains.IsNullOrEmpty())
            {
                return null;
            }

            return domains[0];
        }

 public bool CheckCommodityOwnerTypeIsUsed(CommodityOwnerType commodityOwnerType, EntityStatus intendedStatus)
 {
     if (intendedStatus == EntityStatus.Inactive)
     {
         if (_ctx.tblCommodityOwner.Any(n => n.CommodityOwnerTypeId == commodityOwnerType.Id && n.IM_Status == (int)EntityStatus.Active))
             return true;
     }
     else if (intendedStatus == EntityStatus.Deleted)
     {
         if (_ctx.tblCommodityOwner.Any(n => n.CommodityOwnerTypeId == commodityOwnerType.Id &&
             (n.IM_Status == (int)EntityStatus.Inactive || n.IM_Status == (int)EntityStatus.Active)))
             return true;
     }
     return false;
 }

        public void Save()
        {
            switch ( this.EntityStatus )
            {
                case EntityStatus.Dirty:
                    Client.Current.UpdateEntity( this );
                    this.entityStatus = EntityStatus.Clean;
                    break;

                case EntityStatus.New:
                    Client.Current.CreateEntity( this );
                    this.entityStatus = EntityStatus.Clean;
                    break;

                case EntityStatus.Deleted:
                case EntityStatus.Conflict:
                    throw new InvalidOperationException();
            }
        }

 public static Status ToStatus(EntityStatus status)
 {
     switch (status)
     {
         case EntityStatus.Idle:
             return MemoryAPI.Status.Standing;
         case EntityStatus.Engaged:
             return MemoryAPI.Status.Fighting;
         case EntityStatus.Dead:
             return MemoryAPI.Status.Dead1;
         case EntityStatus.DeadEngaged:
             return MemoryAPI.Status.Dead2;
         case EntityStatus.Event:
             return MemoryAPI.Status.Event;
         case EntityStatus.Healing:
             return MemoryAPI.Status.Healing;
         default:
             return MemoryAPI.Status.Unknown;
     }
 }

 public Competitor(Guid id, DateTime dateCreated, DateTime dateLastUpdated, EntityStatus isActive)
     : base(id, dateCreated, dateLastUpdated, isActive)
 { 
 
 }

 public void ReadPacket(MinecraftStream stream)
 {
     EntityId = stream.ReadInt32();
     Status = (EntityStatus)stream.ReadUInt8();
 }

 public EntityStatusPacket(int entityId, EntityStatus status)
 {
     EntityId = entityId;
     Status = status;
 }

        public Containment(Guid id, DateTime dateCreated, DateTime dateLastUpdated, EntityStatus isActive)
            : base(id, dateCreated, dateLastUpdated, isActive)
        {

        }