// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.or;

import java.sql.*;
import java.util.*;

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

public abstract class DBInvoicePO extends PersistentObjectImpl<DBInvoice>
{
    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

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

    protected DBInvoicePO( Transaction pTransaction ) // Only used for New
    {
        super( DBInvoiceMetaData.INSTANCE, pTransaction );
        mID = getNextSequenceNumber( getClass() );
        registerWithTransaction();
    }

    protected DBInvoicePO( ConstructionControl pConstructionControl )
    {
        super( DBInvoiceMetaData.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<DBInvoice>
    {
        public AttributeAccessor_RecordVersion()
        {
            super( "RecordVersion", "RecordVersion" );
        }

        protected RecordVersionHelper getRecordVersionHelper( DBInvoice pPO )
        {
            return pPO.mRecordVersion;
        }
    }

    public static final AttributeAccessorSCD CD_LastModified = new AttributeAccessor_LastModified();

    private Timestamp mLastModified = null;

    public Timestamp getLastModified()
    {
        return mLastModified;
    }

    protected void LLsetLastModified( Timestamp pLastModified )
    {
        verifyMutability( CD_LastModified, mLastModified, pLastModified );
        mLastModified = pLastModified;
    }

    private static class AttributeAccessor_LastModified extends AttributeAccessorSCDsimplePersistedSysSetOnly<DBInvoice> implements NonImportableFeature
    {
        public AttributeAccessor_LastModified()
        {
            super( "LastModified", "LastModified", true, _SimpleTimestamp );
        }

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getLastModified();
        }

        public void db_setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.LLsetLastModified( to_Timestamp( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Created = new AttributeAccessor_Created();

    private Timestamp mCreated = null;

    public Timestamp getCreated()
    {
        return mCreated;
    }

    protected void LLsetCreated( Timestamp pCreated )
    {
        verifyMutability( CD_Created, mCreated, pCreated );
        mCreated = pCreated;
    }

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

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getCreated();
        }

        public void db_setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.LLsetCreated( to_Timestamp( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_ID = new AttributeAccessor_ID();

    private Long mID = null;

    public Long getID()
    {
        return mID;
    }

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

    private static class AttributeAccessor_ID extends AttributeAccessorSCDsimplePersistedReadOnly<DBInvoice> implements NonImportableFeature
    {
        public AttributeAccessor_ID()
        {
            super( "ID", "id", true, _Long );
        }

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getID();
        }

        public void db_setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.LLsetID( to_Long( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Number = new AttributeAccessor_Number();

    private String mNumber;

    public String getNumber()
    {
        return mNumber;
    }

    public void setNumber( String pNumber )
    {
        verifyMutability( CD_Number, mNumber, pNumber );
        mNumber = pNumber;
    }

    private static class AttributeAccessor_Number extends AttributeAccessorSCDsimplePersistedRegular<DBInvoice>
    {
        public AttributeAccessor_Number()
        {
            super( "Number", "Number", false, _String.with( MaxLength.of( 255 ), //
                                                            UiHint.RightAligned ) );
        }

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getNumber();
        }

        public void setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.setNumber( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Paid = new AttributeAccessor_Paid();

    private boolean mPaid;

    public boolean getPaid()
    {
        return mPaid;
    }

    public void setPaid( boolean pPaid )
    {
        verifyMutability( CD_Paid, mPaid, pPaid );
        mPaid = pPaid;
    }

    private static class AttributeAccessor_Paid extends AttributeAccessorSCDsimplePersistedRegular<DBInvoice>
    {
        public AttributeAccessor_Paid()
        {
            super( "Paid", "Paid", false, _Primitive_boolean.with( BooleanDisplayOptions.of( "Paid/Pending" ) ) );
        }

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getPaid();
        }

        public void setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.setPaid( to_boolean( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Company = new AttributeAccessor_Company();

    private String mCompany;

    public String getCompany()
    {
        return mCompany;
    }

    public void setCompany( String pCompany )
    {
        verifyMutability( CD_Company, mCompany, pCompany );
        mCompany = pCompany;
    }

    private static class AttributeAccessor_Company extends AttributeAccessorSCDsimplePersistedRegular<DBInvoice>
    {
        public AttributeAccessor_Company()
        {
            super( "Company", "Company", false, _String.with( MaxLength.of( 255 ) ) );
        }

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getCompany();
        }

        public void setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.setCompany( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_DateOrdered = new AttributeAccessor_DateOrdered();

    private Timestamp mDateOrdered = null;

    public Timestamp getDateOrdered()
    {
        return mDateOrdered;
    }

    public void setDateOrdered( Timestamp pDateOrdered )
    {
        verifyMutability( CD_DateOrdered, mDateOrdered, pDateOrdered );
        mDateOrdered = pDateOrdered;
    }

    private static class AttributeAccessor_DateOrdered extends AttributeAccessorSCDsimplePersistedRegular<DBInvoice>
    {
        public AttributeAccessor_DateOrdered()
        {
            super( "DateOrdered", "dateOrdered", false, _SimpleTimestamp );
        }

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getDateOrdered();
        }

        public void setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.setDateOrdered( to_Timestamp( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_ContactedAndResolved = new AttributeAccessor_ContactedAndResolved();

    private Boolean mContactedAndResolved;

    public Boolean getContactedAndResolved()
    {
        return mContactedAndResolved;
    }

    public void setContactedAndResolved( Boolean pContactedAndResolved )
    {
        verifyMutability( CD_ContactedAndResolved, mContactedAndResolved, pContactedAndResolved );
        mContactedAndResolved = pContactedAndResolved;
    }

    private static class AttributeAccessor_ContactedAndResolved extends AttributeAccessorSCDsimplePersistedRegular<DBInvoice>
    {
        public AttributeAccessor_ContactedAndResolved()
        {
            super( "ContactedAndResolved", "ContactedAndResolved", false, _Boolean );
        }

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getContactedAndResolved();
        }

        public void setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.setContactedAndResolved( to_Boolean( pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoManyRegular<DBInvoice, DBLineItem> CD_DBLineItemSetForInvoice = new AttributeAccessor_DBLineItemSetForInvoice();

    protected LazyLoadToManyRegular<DBInvoice, DBLineItem> mDBLineItemSetForInvoice = new LazyLoadToManyRegular<DBInvoice, DBLineItem>( (DBInvoice) this, CD_DBLineItemSetForInvoice );

    public List<DBLineItem> getDBLineItemSetForInvoice()
    {
        return processLazyLoadAccess( mDBLineItemSetForInvoice );
    }

    public void setDBLineItemSetForInvoice( List<DBLineItem> pDBLineItemSetForInvoice )
    {
        processLazyLoadMutation( mDBLineItemSetForInvoice, pDBLineItemSetForInvoice );
    }

    public void addDBLineItemSetForInvoice( DBLineItem pDBLineItem )
    {
        processLazyLoadMutationAdd( mDBLineItemSetForInvoice, pDBLineItem );
    }

    public void removeDBLineItemSetForInvoice( DBLineItem pDBLineItem )
    {
        processLazyLoadMutationRemove( mDBLineItemSetForInvoice, pDBLineItem );
    }

    private static class AttributeAccessor_DBLineItemSetForInvoice extends AttributeAccessorSCDtoManyRegular<DBInvoice, DBLineItem>
    {
        public AttributeAccessor_DBLineItemSetForInvoice()
        {
            super( "DBLineItemSetForInvoice", "ID", DBLineItem.class, "Invoice", null, Mutability.RW, false, true );
        }

        public LazyLoadToManyRegular<DBInvoice, DBLineItem> getValueHolder( DBInvoice pPO )
        {
            return pPO.mDBLineItemSetForInvoice;
        }

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getDBLineItemSetForInvoice();
        }

        public void setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.setDBLineItemSetForInvoice( to_POs( pPO, DBLineItem.class, pValue ) );
        }

        public void addValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.addDBLineItemSetForInvoice( to_PO( pPO, DBLineItem.class, pValue ) );
        }

        public void removeValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.removeDBLineItemSetForInvoice( to_PO( pPO, DBLineItem.class, pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoManyRegular<DBInvoice, DBTag> CD_DBTagSetForInvoice = new AttributeAccessor_DBTagSetForInvoice();

    protected LazyLoadToManyRegular<DBInvoice, DBTag> mDBTagSetForInvoice = new LazyLoadToManyRegular<DBInvoice, DBTag>( (DBInvoice) this, CD_DBTagSetForInvoice );

    public List<DBTag> getDBTagSetForInvoice()
    {
        return processLazyLoadAccess( mDBTagSetForInvoice );
    }

    public void setDBTagSetForInvoice( List<DBTag> pDBTagSetForInvoice )
    {
        processLazyLoadMutation( mDBTagSetForInvoice, pDBTagSetForInvoice );
    }

    public void addDBTagSetForInvoice( DBTag pDBTag )
    {
        processLazyLoadMutationAdd( mDBTagSetForInvoice, pDBTag );
    }

    public void removeDBTagSetForInvoice( DBTag pDBTag )
    {
        processLazyLoadMutationRemove( mDBTagSetForInvoice, pDBTag );
    }

    private static class AttributeAccessor_DBTagSetForInvoice extends AttributeAccessorSCDtoManyRegular<DBInvoice, DBTag>
    {
        public AttributeAccessor_DBTagSetForInvoice()
        {
            super( "DBTagSetForInvoice", "ID", DBTag.class, "Invoice", null, Mutability.RW, false, true );
        }

        public LazyLoadToManyRegular<DBInvoice, DBTag> getValueHolder( DBInvoice pPO )
        {
            return pPO.mDBTagSetForInvoice;
        }

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getDBTagSetForInvoice();
        }

        public void setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.setDBTagSetForInvoice( to_POs( pPO, DBTag.class, pValue ) );
        }

        public void addValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.addDBTagSetForInvoice( to_PO( pPO, DBTag.class, pValue ) );
        }

        public void removeValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.removeDBTagSetForInvoice( to_PO( pPO, DBTag.class, pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoManyVariable<DBInvoice, DBNote> CD_Notes = new AttributeAccessor_Notes();

    protected LazyLoadToManyVariable<DBInvoice, DBNote> mNotes = new LazyLoadToManyVariable<DBInvoice, DBNote>( (DBInvoice) this, CD_Notes );

    public List<DBNote> getNotes()
    {
        return processLazyLoadAccess( mNotes );
    }

    public void setNotes( List<DBNote> pNotes )
    {
        processLazyLoadMutation( mNotes, pNotes );
    }

    public void addNotes( DBNote pDBNote )
    {
        processLazyLoadMutationAdd( mNotes, pDBNote );
    }

    public void removeNotes( DBNote pDBNote )
    {
        processLazyLoadMutationRemove( mNotes, pDBNote );
    }

    private static class AttributeAccessor_Notes extends AttributeAccessorSCDtoManyVariable<DBInvoice, DBNote>
    {
        public AttributeAccessor_Notes()
        {
            super( "Notes", DBNote.class, "Owner", null, true, false, Mutability.RW );
        }

        public LazyLoadToManyVariable<DBInvoice, DBNote> getValueHolder( DBInvoice pPO )
        {
            return pPO.mNotes;
        }

        public Object getValueOnPO( DBInvoice pPO )
        {
            return pPO.getNotes();
        }

        public void setValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.setNotes( to_POs( pPO, DBNote.class, pValue ) );
        }

        public void addValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.addNotes( to_PO( pPO, DBNote.class, pValue ) );
        }

        public void removeValueOnPO( DBInvoice pPO, Object pValue )
        {
            pPO.removeNotes( to_PO( pPO, DBNote.class, pValue ) );
        }
    }

    static class MyMetaData extends PersistentObjectImplMetaData<DBInvoice>
    {
        public static final String OBJECT_NAME = "DBInvoice";
        public static final String TABLE_NAME = "DBInvoice";

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

                   CD_Company, //
                   CD_ContactedAndResolved, //
                   CD_Created, //
                   CD_DateOrdered, //
                   CD_LastModified, //
                   CD_Number, //
                   CD_Paid, //
                   CD_RecordVersion, //

                   CD_DBLineItemSetForInvoice, //
                   CD_Notes );
            setIndexes( new Index( "DBInvoiceIDX1", null, true, CD_Number ) );
        }

        public Class getPOclass()
        {
            return DBInvoice.class;
        }

        public DBInvoice createNew( Transaction pTransaction )
        {
            return new DBInvoice( pTransaction );
        }

        public DBInvoice createPOfromFinder()
        {
            return new DBInvoice( CONSTRUCTION_CONTROL );
        }

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

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

        protected void setCreationTimestamp( DBInvoice pPersistentObject, Timestamp pTransactionTimeStamp )
        {
            pPersistentObject.LLsetCreated( pTransactionTimeStamp );
        }

        public String getTransactionTimestampAttributeName()
        {
            return CD_LastModified.getName();
        }

        protected void setTransactionTimestamp( DBInvoice pPersistentObject, Timestamp pTransactionTimeStamp )
        {
            pPersistentObject.LLsetLastModified( pTransactionTimeStamp );
        }

        public String getDisplayValueFormat()
        {
            return "${Number}";
        }
    }
}