Exemplo n.º 1
0
 def cronTest(self):
     self.logger.info("cronTest")
     dateFormat = DateFormat.getDateInstance(DateFormat.SHORT,
                                             Locale.GERMAN)
     assert CronExpression("* * * ? * SAT,SUN *").isSatisfiedBy(
         dateFormat.parse("29.07.2017"))
     assert CronExpression("* * * ? * SAT,SUN *").isSatisfiedBy(
         dateFormat.parse("30.07.2017"))
     assert CronExpression("* * * ? * SAT,SUN *").isSatisfiedBy(
         dateFormat.parse("03.09.2017"))
Exemplo n.º 2
0
 def __init__( self, data, headings ) :
     info = []
     df   = DateFormat.getDateInstance( DateFormat.SHORT )
     for date, size, path in data :
         info.append(
             [
                 df.parse( date ),
                 Integer( size.strip().replace( ',', '' ) ),
                 String( path )
             ]
         )
     DefaultTableModel.__init__( self, info, headings )
Exemplo n.º 3
0
 def __init__(self, data, headings):
     info = []
     df = DateFormat.getDateInstance(DateFormat.SHORT)
     for tf, date, size, f, d in data:
         info.append([
             Boolean(tf == '1'),
             df.parse(date),
             Integer(size.strip().replace(',', '')),
             Float(f),
             Double(d)
         ])
     DefaultTableModel.__init__(self, info, headings)
Exemplo n.º 4
0
    def getDailyScheduleName(self):
        self.scheduleName = None
        now = Date()
        for calendarItem in self.config:
            self.logger.info("Parser: found calendar item: " +
                             str(calendarItem))
            # check if daily schedule exists:
            try:
                self.schedules.getSchedules(calendarItem['daily_schedule'])
            except Exception as e:
                self.logger.warn("Config Error" + str(e))
                raise e

            if calendarItem.get('cron') != None:
                cronExpression = "* * * " + calendarItem.get('cron')
                self.logger.debug(cronExpression)
                self.logger.debug(now)
                if CronExpression(cronExpression).isSatisfiedBy(now):
                    # don't break we want to test the config
                    if self.scheduleName == None:
                        self.scheduleName = calendarItem['daily_schedule']
            else:  # has to be timerange
                df = DateFormat.getDateInstance(DateFormat.SHORT,
                                                Locale.GERMAN)
                fromDate = df.parse(calendarItem['timerange']['from'])
                toDate = df.parse(calendarItem['timerange']['to'])
                self.logger.debug(calendarItem['timerange']['from'])
                self.logger.debug(fromDate)
                self.logger.debug(calendarItem['timerange']['to'])
                self.logger.debug(toDate)
                self.logger.debug(now)
                if now.before(toDate) and now.after(fromDate):
                    # don't break we want to test the config
                    if self.scheduleName == None:
                        self.scheduleName = calendarItem['daily_schedule']

        if self.scheduleName == None:
            self.logger.warn("Todays daily schedule: " +
                             str(self.scheduleName))
        else:
            self.logger.info("todays daily schedule: " +
                             str(self.scheduleName))
        return self.scheduleName
Exemplo n.º 5
0
def setColumnWidths(table):
    #---------------------------------------------------------------------------
    # It's possible for this table to not have a header...
    #---------------------------------------------------------------------------
    header = table.getTableHeader()
    if header:
        hRenderer = header.getDefaultRenderer()
    else:
        hRenderer = None

    #---------------------------------------------------------------------------
    # Variables used to access the table properties and data
    #---------------------------------------------------------------------------
    tcm = table.getColumnModel()  # Table Column Model
    data = table.getModel()  # To access table data
    margin = tcm.getColumnMargin()  # gap between columns

    #---------------------------------------------------------------------------
    # For each column, determine the maximum width required
    #---------------------------------------------------------------------------
    rows = data.getRowCount()  # Number of rows
    cols = tcm.getColumnCount()  # Number of cols

    #---------------------------------------------------------------------------
    # Used for parse & format date strings & objects
    #---------------------------------------------------------------------------
    df = DateFormat.getDateInstance(DateFormat.MEDIUM)

    tWidth = 0  # Table width
    for i in range(cols):  # For col 0..N
        col = tcm.getColumn(i)  # TableColumn: col i
        idx = col.getModelIndex()  # model index: col i

        #-----------------------------------------------------------------------
        # To determine the preferred column width, we
        # must use the current renderer for this column
        #-----------------------------------------------------------------------
        render = col.getHeaderRenderer()  # header renderer,
        if not render:  #
            render = hRenderer  #   or a default

        #-----------------------------------------------------------------------
        # Get preferred header width for column i
        #-----------------------------------------------------------------------
        if render:
            comp = render.getTableCellRendererComponent(
                table, col.getHeaderValue(), 0, 0, -1, i)
            cWidth = comp.getPreferredSize().width
        else:
            cWidth = -1
        #-----------------------------------------------------------------------
        # Compute the maximum width required for the data values in this column
        #-----------------------------------------------------------------------
        Type = data.getColumnClass(i)  # dataType: col i
        for row in range(rows):
            v = data.getValueAt(row, idx)  # value
            if Type == Date:
                val = df.format(v)  # formatted date
                r = table.getDefaultRenderer(String)
            else:
                val = Type(v)
                r = table.getCellRenderer(row, i)
            comp = r.getTableCellRendererComponent(
                table,
                val,  # formatted value
                0,  # not selected
                0,  # not in focus
                row,  # row num
                i  # col num
            )
            cWidth = max(cWidth, comp.getPreferredSize().width)

        if cWidth > 0:
            col.setPreferredWidth(cWidth + margin)

        #-----------------------------------------------------------------------
        # Table width = sum of column widths
        #-----------------------------------------------------------------------
        tWidth += col.getPreferredWidth()

    #---------------------------------------------------------------------------
    # Set the preferred viewport size so we don't (initially) see scrollbars
    # Note: This assumes a uniform row height for every row
    #---------------------------------------------------------------------------
    table.setPreferredScrollableViewportSize(
        Dimension(tWidth, rows * table.getRowHeight()))
Exemplo n.º 6
0
 def put(self, item):
     self.lblLabel.setText(item.getCaption())
     v = item.getValue()
     if v in ("", None):
         v = DateFormat.getDateInstance(DateFormat.SHORT).format(Date())
     self.btnDo.setText(v)
Exemplo n.º 7
0
from java.util import Date
from java.util import Locale
from java.text import DateFormat
dateFormatter = DateFormat.getDateInstance(DateFormat.FULL, Locale.FRANCE);
today = Date()
print today
dateOut = dateFormatter.format(today);
print dateOut