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.*;

public abstract class StoryTemplateGO
        extends org.litesoft.orsup.nonpublic.PersistentObjectImpl<StoryTemplate>
        implements HasAttributes
{
    public static final String[] sValidOptionsRecurrenceReminder = //
            { //
              StoryTemplateNames.poRecurrenceReminder_Don_t_Remind, //
              StoryTemplateNames.poRecurrenceReminder_Remind, //
              StoryTemplateNames.poRecurrenceReminder_Auto, //
            };

    public static final String[] sValidOptionsSchedulePeriod = //
            { //
              StoryTemplateNames.poSchedulePeriod_Daily, //
              StoryTemplateNames.poSchedulePeriod_Weekly, //
              StoryTemplateNames.poSchedulePeriod_Bi_weekly, //
              StoryTemplateNames.poSchedulePeriod_Monthly, //
              StoryTemplateNames.poSchedulePeriod_Yearly, //
            };

    public static final String[] sValidOptionsTaskType = //
            { //
              StoryTemplateNames.poTaskType_Internal, //
              StoryTemplateNames.poTaskType_External, //
            };

    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

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

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

    protected StoryTemplateGO( ConstructionControl pConstructionControl )
    {
        super( StoryTemplateMetaData.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<StoryTemplate>
    {
        public AttributeAccessor_RecordVersion()
        {
            super( "RecordVersion", "RecordVersion" );
        }

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

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

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

    public static final AttributeAccessorSCD CD_Descripiton = new AttributeAccessor_Descripiton();

    private String mDescripiton;

    public String getDescripiton()
    {
        return mDescripiton;
    }

    public void setDescripiton( String pDescripiton )
    {
        verifyMutability( CD_Descripiton, mDescripiton, pDescripiton );
        mDescripiton = pDescripiton;
    }

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

        @Override
        public Object getValueOnPO( StoryTemplate pPO )
        {
            return pPO.getDescripiton();
        }

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

    public static final AttributeAccessorSCD CD_Name = new AttributeAccessor_Name();

    private String mName;

    /**
     * UniqueGroup:1
     */
    public String getName()
    {
        return mName;
    }

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

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

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

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

    public static final AttributeAccessorSCD CD_NextRecurranceDate = new AttributeAccessor_NextRecurranceDate();

    final org.litesoft.orsup.lazyeval.LazyEvalSimpleDate mNextRecurranceDate = new org.litesoft.orsup.lazyeval.LazyEvalSimpleDate();

    /**
     * Used in case of Daily, Monthly, and Yearly
     */
    public org.litesoft.core.simpletypes.temporal.SimpleDate getNextRecurranceDate()
    {
        return mNextRecurranceDate.getSimpleDate();
    }

    public void setNextRecurranceDate( org.litesoft.core.simpletypes.temporal.SimpleDate pNextRecurranceDate )
    {
        verifyMutability( CD_NextRecurranceDate, mNextRecurranceDate.getSimpleDate(), pNextRecurranceDate );
        mNextRecurranceDate.setSimpleDate( pNextRecurranceDate );
    }

    private static class AttributeAccessor_NextRecurranceDate
            extends AttributeAccessorSCDsimplePersistedRegular<StoryTemplate>
    {
        public AttributeAccessor_NextRecurranceDate()
        {
            super( "NextRecurranceDate", "NextRecurranceDate", false, _SimpleDate );
        }

        @Override
        public Object getValueOnPO( StoryTemplate pPO )
        {
            return pPO.getNextRecurranceDate();
        }

        @Override
        public void setValueOnPO( StoryTemplate pPO, Object pValue )
        {
            pPO.setNextRecurranceDate( to_SimpleDate( pPO.mNextRecurranceDate.getDateRes(), pValue ) );
        }

        @Override
        public Object db_getValueOnPO( StoryTemplate pPO )
        {
            return pPO.mNextRecurranceDate.getPersistFormSimpleDate();
        }

        @Override
        public void db_setValueOnPO( StoryTemplate pPO, Object pValue )
        {
            pPO.mNextRecurranceDate.setPersistFormSimpleDate( 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<StoryTemplate>
    {
        public AttributeAccessor_Priority()
        {
            super( "Priority", "Priority", false, _Float.with( DisplayLength.of( 9 ) ) );
        }

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

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

    public static final AttributeAccessorSCD CD_RecurrenceReminder = new AttributeAccessor_RecurrenceReminder();

    private String mRecurrenceReminder;

    public String getRecurrenceReminder()
    {
        return mRecurrenceReminder;
    }

    public void setRecurrenceReminder( String pRecurrenceReminder )
    {
        verifyMutability( CD_RecurrenceReminder, mRecurrenceReminder, pRecurrenceReminder );
        mRecurrenceReminder = pRecurrenceReminder;
    }

    private static class AttributeAccessor_RecurrenceReminder
            extends AttributeAccessorSCDsimplePersistedRegular<StoryTemplate>
    {
        public AttributeAccessor_RecurrenceReminder()
        {
            super( "RecurrenceReminder", "RecurrenceReminder", false, _ValidOptions.with( Options.of( sValidOptionsRecurrenceReminder ) ) );
        }

        @Override
        public Object getValueOnPO( StoryTemplate pPO )
        {
            return pPO.getRecurrenceReminder();
        }

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

    public static final AttributeAccessorSCD CD_ResonsibleParty = new AttributeAccessor_ResonsibleParty();

    private String mResonsibleParty;

    public String getResonsibleParty()
    {
        return mResonsibleParty;
    }

    public void setResonsibleParty( String pResonsibleParty )
    {
        verifyMutability( CD_ResonsibleParty, mResonsibleParty, pResonsibleParty );
        mResonsibleParty = pResonsibleParty;
    }

    private static class AttributeAccessor_ResonsibleParty
            extends AttributeAccessorSCDsimplePersistedRegular<StoryTemplate>
    {
        public AttributeAccessor_ResonsibleParty()
        {
            super( "ResonsibleParty", "ResonsibleParty", false, _String.with( MaxLength.of( 40 ), //
                                                                              DisplayLength.of( 20 ) ) );
        }

        @Override
        public Object getValueOnPO( StoryTemplate pPO )
        {
            return pPO.getResonsibleParty();
        }

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

    public static final AttributeAccessorSCD CD_SchedulePeriod = new AttributeAccessor_SchedulePeriod();

    private String mSchedulePeriod;

    public String getSchedulePeriod()
    {
        return mSchedulePeriod;
    }

    public void setSchedulePeriod( String pSchedulePeriod )
    {
        verifyMutability( CD_SchedulePeriod, mSchedulePeriod, pSchedulePeriod );
        mSchedulePeriod = pSchedulePeriod;
    }

    private static class AttributeAccessor_SchedulePeriod
            extends AttributeAccessorSCDsimplePersistedRegular<StoryTemplate>
    {
        public AttributeAccessor_SchedulePeriod()
        {
            super( "SchedulePeriod", "SchedulePeriod", false, _OpenValidOptions.with( Options.of( sValidOptionsSchedulePeriod ) ) );
        }

        @Override
        public Object getValueOnPO( StoryTemplate pPO )
        {
            return pPO.getSchedulePeriod();
        }

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

    public static final AttributeAccessorSCD CD_TaskDueDateFromTaskCreation = new AttributeAccessor_TaskDueDateFromTaskCreation();

    private Integer mTaskDueDateFromTaskCreation;

    public Integer getTaskDueDateFromTaskCreation()
    {
        return mTaskDueDateFromTaskCreation;
    }

    public void setTaskDueDateFromTaskCreation( Integer pTaskDueDateFromTaskCreation )
    {
        verifyMutability( CD_TaskDueDateFromTaskCreation, mTaskDueDateFromTaskCreation, pTaskDueDateFromTaskCreation );
        mTaskDueDateFromTaskCreation = pTaskDueDateFromTaskCreation;
    }

    private static class AttributeAccessor_TaskDueDateFromTaskCreation
            extends AttributeAccessorSCDsimplePersistedRegular<StoryTemplate>
    {
        public AttributeAccessor_TaskDueDateFromTaskCreation()
        {
            super( "TaskDueDateFromTaskCreation", "TaskDueDateFromTaskCreation", false, _Integer.with( DisplayLength.of( 10 ) ) );
        }

        @Override
        public Object getValueOnPO( StoryTemplate pPO )
        {
            return pPO.getTaskDueDateFromTaskCreation();
        }

        @Override
        public void setValueOnPO( StoryTemplate pPO, Object pValue )
        {
            pPO.setTaskDueDateFromTaskCreation( to_Integer( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_TaskType = new AttributeAccessor_TaskType();

    private String mTaskType;

    public String getTaskType()
    {
        return mTaskType;
    }

    public void setTaskType( String pTaskType )
    {
        verifyMutability( CD_TaskType, mTaskType, pTaskType );
        mTaskType = pTaskType;
    }

    private static class AttributeAccessor_TaskType
            extends AttributeAccessorSCDsimplePersistedRegular<StoryTemplate>
    {
        public AttributeAccessor_TaskType()
        {
            super( "TaskType", "TaskType", false, _OpenValidOptions.with( Options.of( sValidOptionsTaskType ) ) );
        }

        @Override
        public Object getValueOnPO( StoryTemplate pPO )
        {
            return pPO.getTaskType();
        }

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

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

    protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<StoryTemplate,Story> mStories = //
            new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<StoryTemplate,Story>( (StoryTemplate) 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<StoryTemplate,Story>
    {
        public AttributeAccessor_Stories()
        {
            super( "Stories", "ID", Story.class, "StoryTemplate", null, Mutability.RW, false, false );
        }

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

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

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

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

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

    public static final AttributeAccessorSCDtoManyRegular<StoryTemplate,TaskTemplate> CD_TaskTemplates = new AttributeAccessor_TaskTemplates();

    protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<StoryTemplate,TaskTemplate> mTaskTemplates = //
            new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<StoryTemplate,TaskTemplate>( (StoryTemplate) this, CD_TaskTemplates );

    public java.util.List<TaskTemplate> getTaskTemplates()
    {
        return processLazyLoadAccess( mTaskTemplates );
    }

    public void setTaskTemplates( java.util.List<TaskTemplate> pTaskTemplates )
    {
        processLazyLoadMutation( mTaskTemplates, pTaskTemplates );
    }

    public void addTaskTemplates( TaskTemplate pTaskTemplates )
    {
        processLazyLoadMutationAdd( mTaskTemplates, pTaskTemplates );
    }

    public void removeTaskTemplates( TaskTemplate pTaskTemplates )
    {
        processLazyLoadMutationRemove( mTaskTemplates, pTaskTemplates );
    }

    private static class AttributeAccessor_TaskTemplates
            extends AttributeAccessorSCDtoManyRegular<StoryTemplate,TaskTemplate>
    {
        public AttributeAccessor_TaskTemplates()
        {
            super( "TaskTemplates", "ID", TaskTemplate.class, "StoryTemplate", null, Mutability.RW, false, false );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<StoryTemplate,TaskTemplate> getValueHolder( StoryTemplate pPO )
        {
            return pPO.mTaskTemplates;
        }

        @Override
        public Object getValueOnPO( StoryTemplate pPO )
        {
            return pPO.getTaskTemplates();
        }

        @Override
        public void setValueOnPO( StoryTemplate pPO, Object pValue )
        {
            pPO.setTaskTemplates( to_POs( pPO, TaskTemplate.class, pValue ) );
        }

        @Override
        public void addValueOnPO( StoryTemplate pPO, Object pValue )
        {
            pPO.addTaskTemplates( to_PO( pPO, TaskTemplate.class, pValue ) );
        }

        @Override
        public void removeValueOnPO( StoryTemplate pPO, Object pValue )
        {
            pPO.removeTaskTemplates( to_PO( pPO, TaskTemplate.class, pValue ) );
        }
    }

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

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

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

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

                   // Regular
                   CD_Descripiton, /* .................. */
                   CD_Name, /* ......................... */
                   CD_NextRecurranceDate, /* ........... */
                   CD_Priority, /* ..................... */
                   CD_RecurrenceReminder, /* ........... */
                   CD_ResonsibleParty, /* .............. */
                   CD_SchedulePeriod, /* ............... */
                   CD_TaskDueDateFromTaskCreation, /* .. */
                   CD_TaskType, /* ..................... */

                   // ToMany
                   CD_Stories, /* ...................... */
                   CD_TaskTemplates /* ................. */ );
        }

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

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

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

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

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