org.openmrs.module.sync.scheduler.CleanupSyncTablesTask.java Source code

Introduction

Here is the source code for org.openmrs.module.sync.scheduler.CleanupSyncTablesTask.java

Source

/**
 * The contents of this file are subject to the OpenMRS Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://license.openmrs.org
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
 * License for the specific language governing rights and limitations
 * under the License.
 *
 * Copyright (C) OpenMRS, LLC.  All Rights Reserved.
 */
package org.openmrs.module.sync.scheduler;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.openmrs.api.APIException;
import org.openmrs.api.context.Context;
import org.openmrs.module.sync.SyncRecordState;
import org.openmrs.module.sync.api.SyncService;
import org.openmrs.module.sync.server.SyncServerRecord;
import org.openmrs.scheduler.tasks.AbstractTask;
import org.springframework.util.StringUtils;

/**
 * This task deletes rows in the sync_record and sync_server_record tables that are older and not
 * needed anymore. (Sync_import is not touched at this point)
 */
public class CleanupSyncTablesTask extends AbstractTask {

    private static Log log = LogFactory.getLog(CleanupSyncTablesTask.class);

    protected static final String PROPERTY_DAYS_BACK = "delete_entries_files_older_than_x_days";

    private Integer DEFAULT_DAYS_BACK_TO_START_DELETE = 90;

    /**
     * Comma delimited list of {@link SyncRecordState} names that will be deleted. These states on
     * the {@link SyncServerRecord} rows.
     */
    protected static final String PROPERTY_STATES_TO_DELETE = "sync_record_states_to_delete";

    // by default let the service decide which states to delete
    private SyncRecordState[] DEFAULT_STATES_TO_DELETE = new SyncRecordState[] {};

    /**
     * Do the actual deleting of tables.
     */
    public void execute() {
        Context.openSession();
        log.debug("Starting sync table cleanup ... ");
        try {
            if (Context.isAuthenticated() == false)
                authenticate();

            // get the possibly user-defined settings
            Map<String, String> props = null;
            if (taskDefinition != null)
                props = taskDefinition.getProperties();

            Integer daysBack = getIntegerProperty(PROPERTY_DAYS_BACK, props, DEFAULT_DAYS_BACK_TO_START_DELETE);

            Calendar today = Calendar.getInstance();
            today.add(Calendar.DATE, -1 * daysBack);
            Date deleteTo = today.getTime();

            SyncRecordState[] statesToDelete = getSyncRecordStateProperty(PROPERTY_STATES_TO_DELETE, props,
                    DEFAULT_STATES_TO_DELETE);

            // do the actual deleting
            SyncService syncService = Context.getService(SyncService.class);
            Integer quantityDeleted = syncService.deleteSyncRecords(statesToDelete, deleteTo);

            log.info("There were " + quantityDeleted + " sync records cleaned out");
        } catch (Throwable t) {
            log.error("Error while doing sync table cleanup", t);
            throw new APIException(t);
        } finally {
            Context.closeSession();
        }
    }

    /**
     * Get the given property name from the given Map object. If not found or if the value is an
     * invalid integer, return defaultValue
     * 
     * @param propertyName the prop key to look for
     * @param props the key-value map to look in
     * @param defaultValue the default integer if the value is invalid
     * @return the defined value for prop in props
     */
    protected static Integer getIntegerProperty(String propertyName, Map<String, String> props,
            Integer defaultValue) {
        if (props != null) {
            String prop = props.get(propertyName);
            if (prop != null) {
                try {
                    return Integer.valueOf(prop);
                } catch (NumberFormatException e) {
                    log.error("Unable to convert property value for " + propertyName + " : '" + prop
                            + "' to an integer");
                }
            }
        }

        return defaultValue;
    }

    /**
     * Get the given property name from the given props and convert it to an array of
     * {@link SyncRecordState}s
     * 
     * @param propertyName the prop key to look for
     * @param props the key-value map to look in
     * @param defaultStates the default array if the value is invalid
     * @return an array of {@link SyncRecordState}s
     */
    protected static SyncRecordState[] getSyncRecordStateProperty(String propertyName, Map<String, String> props,
            SyncRecordState[] defaultStates) {
        if (props != null) {
            String prop = props.get(propertyName);
            if (StringUtils.hasLength(prop)) {
                try {
                    List<SyncRecordState> states = new ArrayList<SyncRecordState>();
                    for (String stateName : prop.split(",")) {
                        SyncRecordState state = SyncRecordState.valueOf(stateName.trim());
                        states.add(state);
                    }
                    return states.toArray(new SyncRecordState[] {});
                } catch (Exception e) {
                    log.error("Unable to convert property value for " + propertyName + " : '" + prop
                            + "' to an array of states");
                }
            }
        }

        return defaultStates;
    }
}