Ticket #1800: TableStringExample.java

package ome.formats.importer.gui;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import Glacier2.CannotCreateSessionException;
import Glacier2.PermissionDeniedException;

import ome.formats.OMEROMetadataStoreClient;
import ome.formats.importer.IObserver;
import omero.ServerError;
import omero.api.IQueryPrx;
import omero.api.ServiceFactoryPrx;
import omero.grid.Column;
import omero.grid.LongColumn;
import omero.grid.StringColumn;
import omero.grid.TablePrx;
import omero.model.OriginalFile;

public class TableStringExample
{
        
        private static String USER = "user";
        private static String PASS = "pass";
        private static String SERVER = "server";
        
    /** Logger for this class. */
    private static Log log = LogFactory.getLog(TableStringExample.class);
    
    ArrayList<IObserver> observers = new ArrayList<IObserver>();
    
    public SimpleDateFormat day = new SimpleDateFormat("MMM d, ''yy");
    public SimpleDateFormat hour = new SimpleDateFormat("HH:mm");
    
    private static final int DEFAULT_BUFFER_SIZE = 3;
    
    private static final int BASE_UID_COLUMN = 0;
    private static final int BASE_DATETIME_COLUMN = 1;
    private static final int BASE_STATUS_COLUMN = 2;
    
    private ServiceFactoryPrx sf;
    private IQueryPrx iQuery;
    private TablePrx baseTable;
    private Column[] baseColumns;
    
    private String dbName = "StringTextExample";
    
    private int lastIndex;

    public void initialize(ServiceFactoryPrx sf)
        throws ServerError {
        this.sf = sf;
        this.iQuery = sf.getQueryService();
        baseColumns = createBaseColumns(DEFAULT_BUFFER_SIZE);
        createBaseTable();
    }
    
    // Creates a number of empty rows of [rows] size for the base history table
    private Column[] createBaseColumns(int rows) {
        Column[] newColumns = new Column[3];
        newColumns[BASE_UID_COLUMN] = new LongColumn("Uid", "", new long[rows]);
        newColumns[BASE_DATETIME_COLUMN] = new StringColumn("DateTime", "", 64, new String[rows]);
        newColumns[BASE_STATUS_COLUMN] = new StringColumn("Status", "", 64, new String[rows]);
        return newColumns;
    }
    
    @SuppressWarnings("deprecation")
        private void createBaseTable() throws ServerError
    {
        List<OriginalFile> files = getOriginalFiles(dbName);
        
        baseTable = sf.sharedResources().newTable(1, dbName);
        baseTable.initialize(baseColumns);
        
        if (files.isEmpty())     
        {
            log.debug("Creating new table.");
            baseTable = sf.sharedResources().newTable(1, dbName);
            if (baseTable == null)
                System.err.println("baseTable is null");
            baseTable.initialize(baseColumns);
        } else {
            log.debug("Using existing table.");
            System.err.println(files.get(0).getPath().getValue());
            baseTable = sf.sharedResources().openTable(files.get(0));
            if (baseTable == null)
                System.err.println("table is null");
        }
    }
  
    private void addBaseTableRow(String import_status) {
        try
        {            
            LongColumn uid = (LongColumn) baseColumns[BASE_UID_COLUMN];
            StringColumn date = (StringColumn) baseColumns[BASE_DATETIME_COLUMN];
            StringColumn status = (StringColumn) baseColumns[BASE_STATUS_COLUMN];
            
            int size = lastIndex + 1;
            Column[] newColumns = createBaseColumns(size); 
            
            LongColumn uid2 = (LongColumn) newColumns[BASE_UID_COLUMN];
                        System.arraycopy(uid.values, 0, uid2.values, 0, size);
                        
            StringColumn date2 = (StringColumn) newColumns[BASE_DATETIME_COLUMN];
                        System.arraycopy(date.values, 0, date2.values, 0, size);
                        
            StringColumn status2 = (StringColumn) newColumns[BASE_STATUS_COLUMN];
                        System.arraycopy(status.values, 0, status2.values, 0, size);
            
                        // Update our references
                        baseColumns = newColumns;
                        uid = (LongColumn) baseColumns[BASE_UID_COLUMN];
                        date = (StringColumn) baseColumns[BASE_DATETIME_COLUMN];
                        status = (StringColumn) baseColumns[BASE_STATUS_COLUMN];
                        
            //uid2.values[size] = size;
            //date2.values[size] = sqlDateTimeFormat.format(new Date());
            //status2.values[size] = import_status;  

            System.err.println("Rows in table:" + baseTable.getNumberOfRows());
            baseTable.addData(baseColumns);   
            baseColumns = createBaseColumns(DEFAULT_BUFFER_SIZE);
        } catch (Throwable t) {
            throw new RuntimeException(t);
        }
    }

    public List<OriginalFile> getOriginalFiles(String fileName)
    {
        try
        {
                List l = iQuery.findAllByString(OriginalFile.class.getName(), "name", fileName, false, null);
                return (List<OriginalFile>) l;
        }
        catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
    }

    public static void main (String[] args) throws CannotCreateSessionException, PermissionDeniedException, ServerError 
    {
        OMEROMetadataStoreClient store = new OMEROMetadataStoreClient();

        store.initialize(USER, PASS, SERVER, 4063);

        TableStringExample hts = new TableStringExample();
        try
        {
            hts.initialize(store.getServiceFactory());
            hts.addBaseTableRow("test");
        } catch (ServerError e)
        {
            throw new RuntimeException(e);
        }
        System.err.println("Done");
    }
}