package org.litesoft.initfrom.server.pos;

import org.litesoft.bo.attributes.*;
import org.litesoft.core.util.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.otherattributeaccessors.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.orsup.transact.*;

public abstract class RestrictedResourceGO
        extends org.litesoft.orsup.nonpublic.PersistentObjectImpl<RestrictedResource>
        implements HasAttributes {
    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

    public static SimpleFromIdentifier from() {
        return RestrictedResourceMetaData.INSTANCE;
    }

    protected RestrictedResourceGO( Transaction pTransaction ) {
        super( RestrictedResourceMetaData.INSTANCE, pTransaction );
        mID = getNextSequenceNumber( getClass() );
        registerWithTransaction();
        setDefaults();
    }

    protected RestrictedResourceGO( ConstructionControl pConstructionControl ) {
        super( RestrictedResourceMetaData.INSTANCE, CONSTRUCTION_CONTROL, pConstructionControl );
    }

    public static final AttributeAccessorSCD CD_RecordVersion = new AttributeAccessor_RecordVersion();

    protected final RecordVersionHelper mRecordVersion = new RecordVersionHelper();

    public Long getRecordVersion() {
        return mRecordVersion.getRecordVersion();
    }

    private static class AttributeAccessor_RecordVersion
            extends AttributeAccessorSCD_RecordVersion<RestrictedResource> {
        public AttributeAccessor_RecordVersion() {
            super( "RecordVersion", "RecordVersion" );
        }

        @Override
        protected RecordVersionHelper getRecordVersionHelper( RestrictedResource pPO ) {
            return pPO.mRecordVersion;
        }
    }

    public static final AttributeAccessorSCD CD_ID = new AttributeAccessor_ID();

    private Long mID;

    public Long getID() {
        return mID;
    }

    protected void LLsetID( Long pID ) {
        verifyMutability( CD_ID, mID, pID );
        mID = pID;
    }

    private static class AttributeAccessor_ID
            extends AttributeAccessorSCDsimplePersistedSysSetOnly<RestrictedResource>
            implements NonImportableFeature {
        public AttributeAccessor_ID() {
            super( "ID", "ID", false, _Long.AddOnly() );
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getID();
        }

        @Override
        public void db_setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.LLsetID( to_Long( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Active = new AttributeAccessor_Active();

    private Boolean mActive;

    public Boolean getActive() {
        return mActive;
    }

    public void setActive( Boolean pActive ) {
        verifyMutability( CD_Active, mActive, pActive );
        mActive = pActive;
    }

    private static class AttributeAccessor_Active
            extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource> {
        public AttributeAccessor_Active() {
            super( "Active", "Active", true, _Boolean );
        }

        @Override
        public Object getDefault() {
            return true;
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getActive();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setActive( to_Boolean( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_CommonEmailDomain = new AttributeAccessor_CommonEmailDomain();

    private String mCommonEmailDomain;

    public String getCommonEmailDomain() {
        return mCommonEmailDomain;
    }

    public void setCommonEmailDomain( String pCommonEmailDomain ) {
        verifyMutability( CD_CommonEmailDomain, mCommonEmailDomain, pCommonEmailDomain );
        mCommonEmailDomain = toLowerCase( pCommonEmailDomain );
    }

    private static class AttributeAccessor_CommonEmailDomain
            extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource> {
        public AttributeAccessor_CommonEmailDomain() {
            super( "CommonEmailDomain", "CommonEmailDomain", false, _String.with( MaxLength.of( 40 ), //
                                                                                  DisplayLength.of( 20 ), //
                                                                                  Case.Lowered ) );
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getCommonEmailDomain();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setCommonEmailDomain( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Name = new AttributeAccessor_Name();

    private String mName;

    /**
     * What the owner wants to call this propety. The public name - Must be Globally Unique.
     */
    public String getName() {
        return mName;
    }

    public void setName( String pName ) {
        verifyMutability( CD_Name, mName, pName );
        mName = pName;
    }

    private static class AttributeAccessor_Name
            extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource>
            implements CharacterCaseIgnored {
        public AttributeAccessor_Name() {
            super( "Name", "Name", true, _String.with( MaxLength.of( 40 ), //
                                                       DisplayLength.of( 20 ), //
                                                       Case.Ignored ) );
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getName();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setName( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Phone = new AttributeAccessor_Phone();

    abstract public String getPhone();

    abstract protected void LLclearPhone();

    abstract protected void LLsetPhone( String pPhone );

    public void setPhone( String pPhone ) {
        verifyMutability( CD_Phone, getPhone(), pPhone );
        LLsetPhone( pPhone );
    }

    private static class AttributeAccessor_Phone
            extends AttributeAccessorSCDsimpleVirtualRegular<RestrictedResource>
            implements CharacterCaseIgnored {
        public AttributeAccessor_Phone() {
            super( "Phone", false, _String.with( MaxLength.of( 20 ), //
                                                 DisplayLength.of( 20 ), //
                                                 Case.Ignored ) );
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getPhone();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setPhone( to_String( pValue ) );
        }

        @Override
        protected void LL_clearVirtualValueOnPO( RestrictedResource pPO ) {
            pPO.LLclearPhone();
        }
    }

    public static final AttributeAccessorSCD CD_URL = new AttributeAccessor_URL();

    private String mURL;

    public String getURL() {
        return mURL;
    }

    public void setURL( String pURL ) {
        verifyMutability( CD_URL, mURL, pURL );
        mURL = pURL;
    }

    private static class AttributeAccessor_URL
            extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource> {
        public AttributeAccessor_URL() {
            super( "URL", "URL", false, _String.with( MaxLength.of( 100 ), //
                                                      DisplayLength.of( 40 ) ) );
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getURL();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setURL( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoManyVariable<RestrictedResource, Email> CD_Emails = new AttributeAccessor_Emails();

    protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Email> mEmails = //
            new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Email>( (RestrictedResource) this, CD_Emails );

    public java.util.List<Email> getEmails() {
        return processLazyLoadAccess( mEmails );
    }

    public void setEmails( java.util.List<Email> pEmails ) {
        processLazyLoadMutation( mEmails, pEmails );
    }

    public void addEmails( Email pEmails ) {
        processLazyLoadMutationAdd( mEmails, pEmails );
    }

    public void removeEmails( Email pEmails ) {
        processLazyLoadMutationRemove( mEmails, pEmails );
    }

    private static class AttributeAccessor_Emails
            extends AttributeAccessorSCDtoManyVariable<RestrictedResource, Email> {
        public AttributeAccessor_Emails() {
            super( "Emails", Email.class, "Owner", null, true, false, Mutability.RW );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Email> getValueHolder( RestrictedResource pPO ) {
            return pPO.mEmails;
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getEmails();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setEmails( to_POs( pPO, Email.class, pValue ) );
        }

        @Override
        public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.addEmails( to_PO( pPO, Email.class, pValue ) );
        }

        @Override
        public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.removeEmails( to_PO( pPO, Email.class, pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, User> CD_LastUsers = new AttributeAccessor_LastUsers();

    protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, User> mLastUsers = //
            new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, User>( (RestrictedResource) this, CD_LastUsers );

    public java.util.List<User> getLastUsers() {
        return processLazyLoadAccess( mLastUsers );
    }

    public void setLastUsers( java.util.List<User> pLastUsers ) {
        processLazyLoadMutation( mLastUsers, pLastUsers );
    }

    public void addLastUsers( User pLastUsers ) {
        processLazyLoadMutationAdd( mLastUsers, pLastUsers );
    }

    public void removeLastUsers( User pLastUsers ) {
        processLazyLoadMutationRemove( mLastUsers, pLastUsers );
    }

    private static class AttributeAccessor_LastUsers
            extends AttributeAccessorSCDtoManyRegular<RestrictedResource, User> {
        public AttributeAccessor_LastUsers() {
            super( "LastUsers", "ID", User.class, "LastRestrictedResource", null, Mutability.RW, false, false );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, User> getValueHolder( RestrictedResource pPO ) {
            return pPO.mLastUsers;
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getLastUsers();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setLastUsers( to_POs( pPO, User.class, pValue ) );
        }

        @Override
        public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.addLastUsers( to_PO( pPO, User.class, pValue ) );
        }

        @Override
        public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.removeLastUsers( to_PO( pPO, User.class, pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoManyVariable<RestrictedResource, Phone> CD_Phones = new AttributeAccessor_Phones();

    protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Phone> mPhones = //
            new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Phone>( (RestrictedResource) this, CD_Phones );

    public java.util.List<Phone> getPhones() {
        return processLazyLoadAccess( mPhones );
    }

    public void setPhones( java.util.List<Phone> pPhones ) {
        processLazyLoadMutation( mPhones, pPhones );
    }

    public void addPhones( Phone pPhones ) {
        processLazyLoadMutationAdd( mPhones, pPhones );
    }

    public void removePhones( Phone pPhones ) {
        processLazyLoadMutationRemove( mPhones, pPhones );
    }

    private static class AttributeAccessor_Phones
            extends AttributeAccessorSCDtoManyVariable<RestrictedResource, Phone> {
        public AttributeAccessor_Phones() {
            super( "Phones", Phone.class, "Owner", null, true, false, Mutability.RW );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Phone> getValueHolder( RestrictedResource pPO ) {
            return pPO.mPhones;
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getPhones();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setPhones( to_POs( pPO, Phone.class, pValue ) );
        }

        @Override
        public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.addPhones( to_PO( pPO, Phone.class, pValue ) );
        }

        @Override
        public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.removePhones( to_PO( pPO, Phone.class, pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, ReportRestrictedResourceCommon> CD_Reports = new AttributeAccessor_Reports();

    protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, ReportRestrictedResourceCommon> mReports = //
            new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, ReportRestrictedResourceCommon>( (RestrictedResource) this, CD_Reports );

    public java.util.List<ReportRestrictedResourceCommon> getReports() {
        return processLazyLoadAccess( mReports );
    }

    public void setReports( java.util.List<ReportRestrictedResourceCommon> pReports ) {
        processLazyLoadMutation( mReports, pReports );
    }

    public void addReports( ReportRestrictedResourceCommon pReports ) {
        processLazyLoadMutationAdd( mReports, pReports );
    }

    public void removeReports( ReportRestrictedResourceCommon pReports ) {
        processLazyLoadMutationRemove( mReports, pReports );
    }

    private static class AttributeAccessor_Reports
            extends AttributeAccessorSCDtoManyRegular<RestrictedResource, ReportRestrictedResourceCommon> {
        public AttributeAccessor_Reports() {
            super( "Reports", "ID", ReportRestrictedResourceCommon.class, "RestrictedResource", null, Mutability.RW, false, true );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, ReportRestrictedResourceCommon> getValueHolder( RestrictedResource pPO ) {
            return pPO.mReports;
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getReports();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setReports( to_POs( pPO, ReportRestrictedResourceCommon.class, pValue ) );
        }

        @Override
        public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.addReports( to_PO( pPO, ReportRestrictedResourceCommon.class, pValue ) );
        }

        @Override
        public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.removeReports( to_PO( pPO, ReportRestrictedResourceCommon.class, pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, Story> CD_Stories = new AttributeAccessor_Stories();

    protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, Story> mStories = //
            new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, Story>( (RestrictedResource) this, CD_Stories );

    public java.util.List<Story> getStories() {
        return processLazyLoadAccess( mStories );
    }

    public void setStories( java.util.List<Story> pStories ) {
        processLazyLoadMutation( mStories, pStories );
    }

    public void addStories( Story pStories ) {
        processLazyLoadMutationAdd( mStories, pStories );
    }

    public void removeStories( Story pStories ) {
        processLazyLoadMutationRemove( mStories, pStories );
    }

    private static class AttributeAccessor_Stories
            extends AttributeAccessorSCDtoManyRegular<RestrictedResource, Story> {
        public AttributeAccessor_Stories() {
            super( "Stories", "ID", Story.class, "RestrictedResource", null, Mutability.RW, false, false );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, Story> getValueHolder( RestrictedResource pPO ) {
            return pPO.mStories;
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getStories();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setStories( to_POs( pPO, Story.class, pValue ) );
        }

        @Override
        public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.addStories( to_PO( pPO, Story.class, pValue ) );
        }

        @Override
        public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.removeStories( to_PO( pPO, Story.class, pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, UserXrefRestrictedResource> CD_Users = new AttributeAccessor_Users();

    protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, UserXrefRestrictedResource> mUsers = //
            new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, UserXrefRestrictedResource>( (RestrictedResource) this, CD_Users );

    public java.util.List<UserXrefRestrictedResource> getUsers() {
        return processLazyLoadAccess( mUsers );
    }

    public void setUsers( java.util.List<UserXrefRestrictedResource> pUsers ) {
        processLazyLoadMutation( mUsers, pUsers );
    }

    public void addUsers( UserXrefRestrictedResource pUsers ) {
        processLazyLoadMutationAdd( mUsers, pUsers );
    }

    public void removeUsers( UserXrefRestrictedResource pUsers ) {
        processLazyLoadMutationRemove( mUsers, pUsers );
    }

    private static class AttributeAccessor_Users
            extends AttributeAccessorSCDtoManyRegular<RestrictedResource, UserXrefRestrictedResource> {
        public AttributeAccessor_Users() {
            super( "Users", "ID", UserXrefRestrictedResource.class, "RestrictedResource", null, Mutability.RW, false, true );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, UserXrefRestrictedResource> getValueHolder( RestrictedResource pPO ) {
            return pPO.mUsers;
        }

        @Override
        public Object getValueOnPO( RestrictedResource pPO ) {
            return pPO.getUsers();
        }

        @Override
        public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.setUsers( to_POs( pPO, UserXrefRestrictedResource.class, pValue ) );
        }

        @Override
        public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.addUsers( to_PO( pPO, UserXrefRestrictedResource.class, pValue ) );
        }

        @Override
        public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
            pPO.removeUsers( to_PO( pPO, UserXrefRestrictedResource.class, pValue ) );
        }
    }

    static class MyMetaData
            extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<RestrictedResource> {
        public static final String OBJECT_NAME = "RestrictedResource";
        public static final String TABLE_NAME = "RestrictedResource";

        MyMetaData() {
            super( OBJECT_NAME, TABLE_NAME, new AttributeAccessorKeySet( CD_ID ), //

                   CD_RecordVersion, /* ...... */

                   CD_ID, /* ................. */

                   // Regular
                   CD_Active, /* ............. Required */
                   CD_CommonEmailDomain, /* .. */
                   CD_Name, /* ............... Required */
                   CD_URL, /* ................ */

                   // Virtual
                   CD_Phone, /* .............. */

                   // ToMany
                   CD_Emails, /* ............. */
                   CD_LastUsers, /* .......... */
                   CD_Phones, /* ............. */
                   CD_Reports, /* ............ */
                   CD_Stories, /* ............ */
                   CD_Users /* ............... */ );
            setIndexes( new Index( "RestrictedResourceMUGIDX1", null, true, CD_Name ) );
        }

        @Override
        public Class getPOclass() {
            return RestrictedResource.class;
        }

        @Override
        public RestrictedResource createNew( Transaction pTransaction ) {
            return new RestrictedResource( pTransaction );
        }

        @Override
        public RestrictedResource createPOfromFinder() {
            return new RestrictedResource( CONSTRUCTION_CONTROL );
        }

        @Override
        public String getDisplayValueFormat() {
            return "${Name}";
        }

        @Override
        public String getRecordVersionAttributeName() {
            return CD_RecordVersion.getName();
        }
    }
}