@Override public void audit(AuditEventRecord record, Task task, OperationResult result) throws SecurityViolationException, SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException { authorize(ModelAuthorizationAction.AUDIT_RECORD, task, result); auditService.audit(record, task); }
@Override public void cleanupAudit(CleanupPolicyType policy, OperationResult parentResult) { Validate.notNull(policy, "Cleanup policy must not be null."); Validate.notNull(parentResult, "Operation result must not be null."); for (AuditService service : services) { service.cleanupAudit(policy, parentResult); } }
@Override public List<AuditEventRecord> listRecords(String query, Map<String, Object> params) { List<AuditEventRecord> result = new ArrayList<>(); for (AuditService service : services) { if (service.supportsRetrieval()) { List<AuditEventRecord> records = service.listRecords(query, params); if (records != null && !records.isEmpty()) { result.addAll(records); } } } return result; }
@Override public long countObjects(String query, Map<String, Object> params) { long count = 0; for (AuditService service : services) { if (service.supportsRetrieval()) { long c = service.countObjects(query, params); count += c; } } return count; }
@Override public void reindexEntry(AuditEventRecord record) { for (AuditService service : services) { if (service.supportsRetrieval()) { service.reindexEntry(record); } } }
@Override public void listRecordsIterative(String query, Map<String, Object> params, AuditResultHandler handler) { for (AuditService service : services) { if (service.supportsRetrieval()) { service.listRecordsIterative(query, params, handler); } } }
private List<AuditEventRecord> getChangeTrail(String targetOid, XMLGregorianCalendar from) { Map<String,Object> params = new HashMap<>(); params.put("from", from); params.put("targetOid", targetOid); params.put("stage", AuditEventStage.EXECUTION); return auditService.listRecords( "from RAuditEventRecord as aer where (aer.timestamp >= :from) and (aer.targetOid = :targetOid) and (aer.eventStage = :stage) order by aer.timestamp desc", params); }
runResult.setOperationResult(opResult); final long expectedTotal = auditService.countObjects("select count(*) from RAuditEventRecord as aer where 1=1", null); AuditResultHandler resultHandler = new AuditResultHandler() { params.put("setFirstResult", firstResult); params.put("setMaxResults", maxResults); List<AuditEventRecord> records = auditService.listRecords(null, params); if (CollectionUtils.isNotEmpty(records)){ for (AuditEventRecord record : records) {
@Override public boolean supportsRetrieval() { for (AuditService service : services) { if (service.supportsRetrieval()) { return true; } } return false; } }
@Override public boolean handle(AuditEventRecord auditRecord) { auditService.reindexEntry(auditRecord); processedObjects.incrementAndGet(); return true; }
@Override public long countObjects(String query, Map<String, Object> params, Task task, OperationResult result) throws SecurityViolationException, SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException { authorize(ModelAuthorizationAction.AUDIT_READ, task, result); return auditService.countObjects(query, params); }
@Override public List<AuditEventRecord> listRecords(String query, Map<String, Object> params, Task task, OperationResult result) throws SecurityViolationException, SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException { authorize(ModelAuthorizationAction.AUDIT_READ, task, result); return auditService.listRecords(query, params); }
@Override public boolean supportsRetrieval() { return auditService.supportsRetrieval(); }
@Override public void audit(AuditEventRecord record, Task task) { if (services.isEmpty()) { LOGGER.warn("Audit event will not be recorded. No audit services registered."); return; } assertCorrectness(record, task); completeRecord(record, task); for (AuditService service : services) { service.audit(record, task); } }
@Override public void cleanupAudit(CleanupPolicyType policy, Task task, OperationResult parentResult) throws SecurityViolationException, SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException { authorize(ModelAuthorizationAction.AUDIT_MANAGE, task, parentResult); auditService.cleanupAudit(policy, parentResult); }
private AuditEventRecord findEvent(String eventIdentifier) { Map<String,Object> params = new HashMap<>(); params.put("eventIdentifier", eventIdentifier); List<AuditEventRecord> listRecords = auditService.listRecords("from RAuditEventRecord as aer where (aer.eventIdentifier = :eventIdentifier)", params); if (listRecords == null || listRecords.isEmpty()) { return null; } if (listRecords.size() > 1) { LOGGER.error("Found "+listRecords.size()+" audit records for event ID "+eventIdentifier+" (expecting just one)"); } return listRecords.get(0); }
private void auditProcessStartEnd(WfTask wfTask, AuditEventStage stage, Map<String, Object> variables, OperationResult result) { AuditEventRecord auditEventRecord = wfTask.getChangeProcessor().prepareProcessInstanceAuditRecord(wfTask, stage, variables, result); auditService.audit(auditEventRecord, wfTask.getTask()); }
@Test public void testAuditCleanupMaxRecords() throws Exception { //GIVEN prepareAuditEventRecords(); //WHEN Calendar calendar = create_2013_07_12_12_00_Calendar(); calendar.add(Calendar.HOUR_OF_DAY, 1); calendar.add(Calendar.MINUTE, 1); final long NOW = System.currentTimeMillis(); CleanupPolicyType policy = createPolicy(1); OperationResult result = new OperationResult("Cleanup audit"); auditService.cleanupAudit(policy, result); result.recomputeStatus(); //THEN RAuditEventRecord record = assertAndReturnAuditEventRecord(result); }
public List<AuditEventRecord> searchAuditRecords(String query, Map<String, Object> params) { if (StringUtils.isBlank(query)) { return new ArrayList<>(); } Map<String, Object> resultSet = new HashMap<>(); Set<Entry<String, Object>> paramSet = params.entrySet(); for (Entry<String, Object> p : paramSet) { if (p.getValue() instanceof AuditEventTypeType) { resultSet.put(p.getKey(), AuditEventType.toAuditEventType((AuditEventTypeType) p.getValue())); } else if (p.getValue() instanceof AuditEventStageType) { resultSet.put(p.getKey(), AuditEventStage.toAuditEventStage((AuditEventStageType) p.getValue())); } else { resultSet.put(p.getKey(), p.getValue()); } } return auditService.listRecords(query, resultSet); }
protected void auditLogin(Task task) { AuditEventRecord record = new AuditEventRecord(AuditEventType.CREATE_SESSION, AuditEventStage.REQUEST); record.setInitiatorAndLoginParameter(task.getOwner()); record.setChannel(SchemaConstants.CHANNEL_WEB_SERVICE_URI); record.setTimestamp(System.currentTimeMillis()); record.setOutcome(OperationResultStatus.SUCCESS); auditService.audit(record, task); }