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

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

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

    protected StoryChangeGO( ConstructionControl pConstructionControl ) {
        super( StoryChangeMetaData.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<StoryChange> {
        public AttributeAccessor_RecordVersion() {
            super( "RecordVersion", "RecordVersion" );
        }

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

    public static final AttributeAccessorSCD CD_Created = new AttributeAccessor_Created();

    final org.litesoft.orsup.lazyeval.LazyEvalSimpleTimestamp mCreated = new org.litesoft.orsup.lazyeval.LazyEvalSimpleTimestamp();

    public org.litesoft.core.simpletypes.temporal.SimpleTimestamp getCreated() {
        return mCreated.getSimpleTimestamp();
    }

    protected void LLsetCreated( org.litesoft.core.simpletypes.temporal.SimpleTimestamp pCreated ) {
        verifyMutability( CD_Created, mCreated.getSimpleTimestamp(), pCreated );
        mCreated.setSimpleTimestamp( pCreated );
    }

    private static class AttributeAccessor_Created
            extends AttributeAccessorSCDsimplePersistedSysSetOnly<StoryChange>
            implements NonImportableFeature {
        public AttributeAccessor_Created() {
            super( "Created", "Created", true, _SimpleTimestamp.RO() );
        }

        @Override
        public Object getValueOnPO( StoryChange pPO ) {
            return pPO.getCreated();
        }

        @Override
        public Object db_getValueOnPO( StoryChange pPO ) {
            return pPO.mCreated.get_java_sql_Timestamp();
        }

        @Override
        public void db_setValueOnPO( StoryChange pPO, Object pValue ) {
            pPO.mCreated.set_java_sql_Timestamp( to_Timestamp( pValue ) );
        }
    }

    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<StoryChange>
            implements NonImportableFeature {
        public AttributeAccessor_ID() {
            super( "ID", "ID", false, _Long.AddOnly() );
        }

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

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

    public static final AttributeAccessorSCDtoOneRegular<StoryChange, StoryUpdate> CD_Update = new AttributeAccessor_Update();

    protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<StoryChange, StoryUpdate> mUpdate = //
            new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<StoryChange, StoryUpdate>( (StoryChange) this, CD_Update );

    public StoryUpdate getUpdate() {
        return processLazyLoadAccess( mUpdate );
    }

    public void setUpdate( StoryUpdate pUpdate ) {
        processLazyLoadMutation( mUpdate, pUpdate );
    }

    private static class AttributeAccessor_Update
            extends AttributeAccessorSCDtoOneRegular<StoryChange, StoryUpdate> {
        public AttributeAccessor_Update() {
            super( "Update", "Update_id", StoryUpdate.class, "ID", "Changes", false, true, Mutability.RW );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<StoryChange, StoryUpdate> getValueHolder( StoryChange pPO ) {
            return pPO.mUpdate;
        }

        @Override
        public Object getValueOnPO( StoryChange pPO ) {
            return pPO.getUpdate();
        }

        @Override
        public void setValueOnPO( StoryChange pPO, Object pValue ) {
            pPO.setUpdate( to_PO( pPO, StoryUpdate.class, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( StoryChange pPO ) {
            return pPO.mUpdate.db_getValue();
        }

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

    public static final AttributeAccessorSCD CD_WasValue = new AttributeAccessor_WasValue();

    private String mWasValue;

    public String getWasValue() {
        return mWasValue;
    }

    public void setWasValue( String pWasValue ) {
        verifyMutability( CD_WasValue, mWasValue, pWasValue );
        mWasValue = pWasValue;
    }

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

        @Override
        public Object getValueOnPO( StoryChange pPO ) {
            return pPO.getWasValue();
        }

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

    public static final AttributeAccessorSCD CD_WhatChanged = new AttributeAccessor_WhatChanged();

    private String mWhatChanged;

    public String getWhatChanged() {
        return mWhatChanged;
    }

    public void setWhatChanged( String pWhatChanged ) {
        verifyMutability( CD_WhatChanged, mWhatChanged, pWhatChanged );
        mWhatChanged = pWhatChanged;
    }

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

        @Override
        public Object getValueOnPO( StoryChange pPO ) {
            return pPO.getWhatChanged();
        }

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

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

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

                   CD_RecordVersion, /* .. */

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

                   // Injected
                   CD_Created, /* ........ Required */

                   // Regular
                   CD_WasValue, /* ....... */
                   CD_WhatChanged, /* .... Required */

                   // ToOne
                   CD_Update /* .......... Required */ );
            setIndexes( new Index( "StoryChange21AIDX1", null, false, CD_Update ) );
        }

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

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

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

        @Override
        public String getDisplayValueFormat() {
            return "${WhatChanged} was: ${WasValue}";
        }

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

        @Override
        public String getDefaultOrderByAttributeName() {
            return "WhatChanged";
        }

        @Override
        public String getCreationTimestampAttributeName() {
            return CD_Created.getName();
        }

        @Override
        protected void setCreationTimestamp( StoryChange pPersistentObject, java.sql.Timestamp pTransactionTimeStamp ) {
            pPersistentObject.LLsetCreated( TypeConverter.to_SimpleTimestamp( pTransactionTimeStamp ) );
        }
    }
}