Ticket #1951: TableStringExample.java

package ome.formats.importer.gui;


import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
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.IUpdatePrx;
import omero.api.ServiceFactoryPrx;
import omero.grid.Column;
import omero.grid.Data;
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);
    }
    
    // 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[]{1});
        newColumns[BASE_DATETIME_COLUMN] = new LongColumn("DateTime", "", new long[]{1});
        newColumns[BASE_STATUS_COLUMN] = new StringColumn("Status", "", 100, new String[]{"c"});
        return newColumns;
    }
    
    @SuppressWarnings("deprecation")
        private void createBaseTable() throws ServerError
    {
        List<OriginalFile> files = getOriginalFiles(dbName);
        
        baseTable = sf.sharedResources().newTable(1, dbName);
        baseTable.initialize(baseColumns);
        
    }
  
    private void addBaseTableRow(String import_status) throws Exception {
            LongColumn uid = (LongColumn) baseColumns[BASE_UID_COLUMN];
            LongColumn date = (LongColumn) baseColumns[BASE_DATETIME_COLUMN];
            StringColumn status = (StringColumn) baseColumns[BASE_STATUS_COLUMN];

            System.err.println("Rows in table:" + baseTable.getNumberOfRows());
            System.err.println("0:" + Arrays.toString(((LongColumn)uid).values));
            System.err.println("1:" + Arrays.toString(((LongColumn)date).values));
            System.err.println("2:" + Arrays.toString(((StringColumn)status).values));
            baseTable.addData(baseColumns);
            baseColumns = createBaseColumns(DEFAULT_BUFFER_SIZE);
    }

    private void clearBaseTable() throws ServerError
    {        
        List<OriginalFile> baseFiles = getOriginalFiles(dbName);
        
        if (baseFiles == null || baseFiles.isEmpty())
        {
                System.err.println("No baseFiles found.");
                return;
        }
        
        for (OriginalFile file : baseFiles)
        {
                System.err.println("Deleting " + file.getName().getValue());
                deleteOriginalFile(file);
                baseTable = null;
        }
    }
    
    private void deleteOriginalFile(final OriginalFile file) throws ServerError {
        IUpdatePrx update = sf.getUpdateService();
        try {
                update.deleteObject(file);
        } catch (ome.conditions.ValidationException e) {
                throw new RuntimeException(e);
        }
    }
    
    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 void displayTableData()
    {
        try {
                
                // base table data
                        System.err.println("Rows in base table:" + baseTable.getNumberOfRows());
                        
                        Data baseData = getBaseTableData();
                        
                LongColumn uids = (LongColumn) baseData.columns[BASE_UID_COLUMN];
                LongColumn baseImportTimes = (LongColumn) baseData.columns[BASE_DATETIME_COLUMN];
                StringColumn baseStatuses = (StringColumn) baseData.columns[BASE_STATUS_COLUMN];
                
                for (int i = 0; i < uids.values.length; i++)
                {
                        System.err.println("UID[" + uids.values[i] + "]: "
                                        + baseImportTimes.values[i] + ", " 
                                        + baseStatuses.values[i].trim() 
                                        );
                }
                        
                } catch (ServerError e) {
                        throw new RuntimeException(e);
                }
    }
    
    public Data getBaseTableData() throws ServerError
    {
        
                long rows = baseTable.getNumberOfRows();
                System.err.println("Number of rows in base Table: " + rows);
                long[] ColNumbers = {BASE_UID_COLUMN, BASE_DATETIME_COLUMN, BASE_STATUS_COLUMN};
            Data d = baseTable.read(ColNumbers, 0L, rows);
            return d;
    }
    
    public static void main (String[] args) throws CannotCreateSessionException, PermissionDeniedException, ServerError, Exception
    {
        OMEROMetadataStoreClient store = new OMEROMetadataStoreClient();
        try {

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

        TableStringExample hts = new TableStringExample();
            hts.initialize(store.getServiceFactory());
            hts.createBaseTable();
            hts.addBaseTableRow(null);
            hts.clearBaseTable();
            hts.createBaseTable();
            hts.addBaseTableRow(null);
            hts.displayTableData();
            //hts.addBaseTableRow("test");
        System.err.println("Done");
        } finally {
            store.logout();
        }
    }
}