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 StoryGO
        extends org.litesoft.orsup.nonpublic.PersistentObjectImpl<Story>
        implements HasAttributes {
    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

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

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

    protected StoryGO( ConstructionControl pConstructionControl ) {
        super( StoryMetaData.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<Story> {
        public AttributeAccessor_RecordVersion() {
            super( "RecordVersion", "RecordVersion" );
        }

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

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

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

    public static final AttributeAccessorSCDtoOneRegular<Story, User> CD_Creator = new AttributeAccessor_Creator();

    protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, User> mCreator = //
            new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, User>( (Story) this, CD_Creator );

    public User getCreator() {
        return processLazyLoadAccess( mCreator );
    }

    public void setCreator( User pCreator ) {
        processLazyLoadMutation( mCreator, pCreator );
    }

    private static class AttributeAccessor_Creator
            extends AttributeAccessorSCDtoOneRegular<Story, User> {
        public AttributeAccessor_Creator() {
            super( "Creator", "Creator_id", User.class, "ID", "Stories", false, true, Mutability.RW );
        }

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

        @Override
        public Object getValueOnPO( Story pPO ) {
            return pPO.getCreator();
        }

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

        @Override
        public Object db_getValueOnPO( Story pPO ) {
            return pPO.mCreator.db_getValue();
        }

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

    public static final AttributeAccessorSCD CD_Description = new AttributeAccessor_Description();

    private String mDescription;

    public String getDescription() {
        return mDescription;
    }

    public void setDescription( String pDescription ) {
        verifyMutability( CD_Description, mDescription, pDescription );
        mDescription = pDescription;
    }

    private static class AttributeAccessor_Description
            extends AttributeAccessorSCDsimplePersistedRegular<Story> {
        public AttributeAccessor_Description() {
            super( "Description", "Description", false, _Text.with( DisplayWidthInitial.of( 40 ), //
                                                                    DisplayHeightInitial.of( 4 ) ) );
        }

        @Override
        public Object getValueOnPO( Story pPO ) {
            return pPO.getDescription();
        }

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

    public static final AttributeAccessorSCD CD_IsDone = new AttributeAccessor_IsDone();

    private Boolean mIsDone;

    public Boolean getIsDone() {
        return mIsDone;
    }

    public void setIsDone( Boolean pIsDone ) {
        verifyMutability( CD_IsDone, mIsDone, pIsDone );
        mIsDone = pIsDone;
    }

    private static class AttributeAccessor_IsDone
            extends AttributeAccessorSCDsimplePersistedRegular<Story> {
        public AttributeAccessor_IsDone() {
            super( "IsDone", "IsDone", false, _Boolean );
        }

        @Override
        public Object getValueOnPO( Story pPO ) {
            return pPO.getIsDone();
        }

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

    public static final AttributeAccessorSCD CD_Name = new AttributeAccessor_Name();

    private String mName;

    public String getName() {
        return mName;
    }

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

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

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

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

    public static final AttributeAccessorSCD CD_Priority = new AttributeAccessor_Priority();

    private Float mPriority;

    /**
     * Allow insertion of priorities in between
     */
    public Float getPriority() {
        return mPriority;
    }

    public void setPriority( Float pPriority ) {
        verifyMutability( CD_Priority, mPriority, pPriority );
        mPriority = pPriority;
    }

    private static class AttributeAccessor_Priority
            extends AttributeAccessorSCDsimplePersistedRegular<Story> {
        public AttributeAccessor_Priority() {
            super( "Priority", "Priority", false, _Float.with( DisplayLength.of( 9 ) ) );
        }

        @Override
        public Object getValueOnPO( Story pPO ) {
            return pPO.getPriority();
        }

        @Override
        public void setValueOnPO( Story pPO, Object pValue ) {
            pPO.setPriority( to_Float( pValue ) );
        }
    }

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

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

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

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

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

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

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

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

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

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

    public static final AttributeAccessorSCDtoOneRegular<Story, StoryTemplate> CD_StoryTemplate = new AttributeAccessor_StoryTemplate();

    protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, StoryTemplate> mStoryTemplate = //
            new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, StoryTemplate>( (Story) this, CD_StoryTemplate );

    public StoryTemplate getStoryTemplate() {
        return processLazyLoadAccess( mStoryTemplate );
    }

    public void setStoryTemplate( StoryTemplate pStoryTemplate ) {
        processLazyLoadMutation( mStoryTemplate, pStoryTemplate );
    }

    private static class AttributeAccessor_StoryTemplate
            extends AttributeAccessorSCDtoOneRegular<Story, StoryTemplate> {
        public AttributeAccessor_StoryTemplate() {
            super( "StoryTemplate", "StoryTemplate_id", StoryTemplate.class, "ID", "Stories", false, false, Mutability.RW );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, StoryTemplate> getValueHolder( Story pPO ) {
            return pPO.mStoryTemplate;
        }

        @Override
        public Object getValueOnPO( Story pPO ) {
            return pPO.getStoryTemplate();
        }

        @Override
        public void setValueOnPO( Story pPO, Object pValue ) {
            pPO.setStoryTemplate( to_PO( pPO, StoryTemplate.class, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( Story pPO ) {
            return pPO.mStoryTemplate.db_getValue();
        }

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

    public static final AttributeAccessorSCDtoManyRegular<Story, Task> CD_Tasks = new AttributeAccessor_Tasks();

    protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story, Task> mTasks = //
            new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story, Task>( (Story) this, CD_Tasks );

    public java.util.List<Task> getTasks() {
        return processLazyLoadAccess( mTasks );
    }

    public void setTasks( java.util.List<Task> pTasks ) {
        processLazyLoadMutation( mTasks, pTasks );
    }

    public void addTasks( Task pTasks ) {
        processLazyLoadMutationAdd( mTasks, pTasks );
    }

    public void removeTasks( Task pTasks ) {
        processLazyLoadMutationRemove( mTasks, pTasks );
    }

    private static class AttributeAccessor_Tasks
            extends AttributeAccessorSCDtoManyRegular<Story, Task> {
        public AttributeAccessor_Tasks() {
            super( "Tasks", "ID", Task.class, "Story", null, Mutability.RW, false, true );
        }

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

        @Override
        public Object getValueOnPO( Story pPO ) {
            return pPO.getTasks();
        }

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

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

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

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

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

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

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

                   // Regular
                   CD_Description, /* ......... */
                   CD_IsDone, /* .............. */
                   CD_Name, /* ................ Required */
                   CD_Priority, /* ............ */

                   // ToOne
                   CD_Creator, /* ............. Required */
                   CD_RestrictedResource, /* .. */
                   CD_StoryTemplate, /* ....... */

                   // ToMany
                   CD_Tasks /* ................ */ );
            setIndexes( new Index( "Story21AIDX3", null, false, CD_StoryTemplate ), //
                        new Index( "Story21AIDX2", null, false, CD_RestrictedResource ), //
                        new Index( "Story21AIDX1", null, false, CD_Creator ), //
                        new Index( "StoryMUGIDX1", null, true, CD_Name, CD_RestrictedResource ) );
        }

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

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

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

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

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