package org.litesoft.prioritizer.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.*;
import org.litesoft.prioritizer.client.support.*;

public abstract class UserXrefRestrictedResourceGO
        extends org.litesoft.orsup.nonpublic.PersistentObjectImpl<UserXrefRestrictedResource>
        implements HasAttributes {
    public static final String[] sValidOptionsStatus = //
            { //
              UserXrefRestrictedResourceNames.poStatus_Active, //
              UserXrefRestrictedResourceNames.poStatus_Vacation, //
              UserXrefRestrictedResourceNames.poStatus_Leave_Of_Absence, //
              UserXrefRestrictedResourceNames.poStatus_Terminated, //
            };

    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

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

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

    protected UserXrefRestrictedResourceGO( ConstructionControl pConstructionControl ) {
        super( UserXrefRestrictedResourceMetaData.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<UserXrefRestrictedResource> {
        public AttributeAccessor_RecordVersion() {
            super( "RecordVersion", "RecordVersion" );
        }

        @Override
        protected RecordVersionHelper getRecordVersionHelper( UserXrefRestrictedResource 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<UserXrefRestrictedResource>
            implements NonImportableFeature {
        public AttributeAccessor_ID() {
            super( "ID", "ID", false, _Long.AddOnly() );
        }

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

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

    public static final AttributeAccessorSCDtoOneRegular<UserXrefRestrictedResource, User> CD_User = new AttributeAccessor_User();

    protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<UserXrefRestrictedResource, User> mUser = //
            new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<UserXrefRestrictedResource, User>( (UserXrefRestrictedResource) this, CD_User );

    public User getUser() {
        return processLazyLoadAccess( mUser );
    }

    public void setUser( User pUser ) {
        processLazyLoadMutation( mUser, pUser );
    }

    private static class AttributeAccessor_User
            extends AttributeAccessorSCDtoOneRegular<UserXrefRestrictedResource, User> {
        public AttributeAccessor_User() {
            super( "User", "User_id", User.class, "ID", "RestrictedResources", false, true, Mutability.RW );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<UserXrefRestrictedResource, User> getValueHolder( UserXrefRestrictedResource pPO ) {
            return pPO.mUser;
        }

        @Override
        public Object getValueOnPO( UserXrefRestrictedResource pPO ) {
            return pPO.getUser();
        }

        @Override
        public void setValueOnPO( UserXrefRestrictedResource pPO, Object pValue ) {
            pPO.setUser( to_PO( pPO, User.class, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( UserXrefRestrictedResource pPO ) {
            return pPO.mUser.db_getValue();
        }

        @Override
        public void db_setValueOnPO( UserXrefRestrictedResource pPO, Object pValue ) {
            pPO.mUser.db_setValue( to_Long( pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoOneRegular<UserXrefRestrictedResource, RestrictedResource> CD_RestrictedResource =
            new AttributeAccessor_RestrictedResource();

    protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<UserXrefRestrictedResource, RestrictedResource> mRestrictedResource = //
            new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<UserXrefRestrictedResource, RestrictedResource>( (UserXrefRestrictedResource) this,
                                                                                                                  CD_RestrictedResource );

    public RestrictedResource getRestrictedResource() {
        return processLazyLoadAccess( mRestrictedResource );
    }

    public void setRestrictedResource( RestrictedResource pRestrictedResource ) {
        processLazyLoadMutation( mRestrictedResource, pRestrictedResource );
    }

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

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

        @Override
        public Object getValueOnPO( UserXrefRestrictedResource pPO ) {
            return pPO.getRestrictedResource();
        }

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

        @Override
        public Object db_getValueOnPO( UserXrefRestrictedResource pPO ) {
            return pPO.mRestrictedResource.db_getValue();
        }

        @Override
        public void db_setValueOnPO( UserXrefRestrictedResource pPO, Object pValue ) {
            pPO.mRestrictedResource.db_setValue( to_Long( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_CanAdministrate = new AttributeAccessor_CanAdministrate();

    private Boolean mCanAdministrate;

    public Boolean getCanAdministrate() {
        return mCanAdministrate;
    }

    public void setCanAdministrate( Boolean pCanAdministrate ) {
        verifyMutability( CD_CanAdministrate, mCanAdministrate, pCanAdministrate );
        mCanAdministrate = pCanAdministrate;
    }

    private static class AttributeAccessor_CanAdministrate
            extends AttributeAccessorSCDsimplePersistedRegular<UserXrefRestrictedResource> {
        public AttributeAccessor_CanAdministrate() {
            super( "CanAdministrate", "CanAdministrate", true, _Boolean );
        }

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

        @Override
        public Object getValueOnPO( UserXrefRestrictedResource pPO ) {
            return pPO.getCanAdministrate();
        }

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

    public static final AttributeAccessorSCD CD_LastRole = new AttributeAccessor_LastRole();

    private String mLastRole;

    public String getLastRole() {
        return mLastRole;
    }

    public void setLastRole( String pLastRole ) {
        verifyMutability( CD_LastRole, mLastRole, pLastRole );
        mLastRole = pLastRole;
    }

    private static class AttributeAccessor_LastRole
            extends AttributeAccessorSCDsimplePersistedRegular<UserXrefRestrictedResource> {
        public AttributeAccessor_LastRole() {
            super( "LastRole", "LastRole", false, _ValidOptions.with( Options.of( Role.OPTIONS ) ) );
        }

        @Override
        public Object getDefault() {
            return "Applicant";
        }

        @Override
        public Object getValueOnPO( UserXrefRestrictedResource pPO ) {
            return pPO.getLastRole();
        }

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

    public static final AttributeAccessorSCD CD_Status = new AttributeAccessor_Status();

    private String mStatus;

    public String getStatus() {
        return mStatus;
    }

    public void setStatus( String pStatus ) {
        verifyMutability( CD_Status, mStatus, pStatus );
        mStatus = pStatus;
    }

    private static class AttributeAccessor_Status
            extends AttributeAccessorSCDsimplePersistedRegular<UserXrefRestrictedResource> {
        public AttributeAccessor_Status() {
            super( "Status", "Status", true, _ValidOptions.with( Options.of( sValidOptionsStatus ) ) );
        }

        @Override
        public Object getDefault() {
            return "Active";
        }

        @Override
        public Object getValueOnPO( UserXrefRestrictedResource pPO ) {
            return pPO.getStatus();
        }

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

    public static final AttributeAccessorSCD CD_Visible = new AttributeAccessor_Visible();

    private Boolean mVisible;

    public Boolean getVisible() {
        return mVisible;
    }

    public void setVisible( Boolean pVisible ) {
        verifyMutability( CD_Visible, mVisible, pVisible );
        mVisible = pVisible;
    }

    private static class AttributeAccessor_Visible
            extends AttributeAccessorSCDsimplePersistedRegular<UserXrefRestrictedResource> {
        public AttributeAccessor_Visible() {
            super( "Visible", "Visible", true, _Boolean );
        }

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

        @Override
        public Object getValueOnPO( UserXrefRestrictedResource pPO ) {
            return pPO.getVisible();
        }

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

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

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

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

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

                   // Regular
                   CD_CanAdministrate, /* ..... Required */
                   CD_LastRole, /* ............ */
                   CD_Status, /* .............. Required */
                   CD_Visible, /* ............. Required */

                   // Bridge
                   CD_User, /* ................ Required */
                   CD_RestrictedResource /* ... Required */ );
            setIndexes( new Index( "UserXrefRestrictedResource21AIDX2", null, false, CD_RestrictedResource ), //
                        new Index( "UserXrefRestrictedResource21AIDX1", null, false, CD_User ) );
        }

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

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

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

        @Override
        public String getDisplayValueFormat() {
            return null;
        }

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