Java AuditService类代码示例

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
protected void cleanupAuditData(final String auditApplicationName, final JobExecutionContext context)
{
    final AuditService auditService = JobUtilities.getJobDataValue(context, "auditService", AuditService.class);

    final String cutOffPeriodStr = JobUtilities.getJobDataValue(context, "cutOffPeriod", String.class);
    final String timezoneStr = JobUtilities.getJobDataValue(context, "timezone", String.class, false);

    final Period cutOffPeriod = Period.parse(cutOffPeriodStr);
    final ZoneId zone = ZoneId.of(timezoneStr != null ? timezoneStr : "Z");
    final ZonedDateTime now = LocalDateTime.now(ZoneId.of("Z")).atZone(zone);
    final ZonedDateTime cutOffDate = now.minus(cutOffPeriod);
    final long epochSecond = cutOffDate.toEpochSecond();

    LOGGER.debug("Clearing all audit entries of application {} until {}", auditApplicationName, cutOffDate);
    auditService.clearAudit(auditApplicationName, null, Long.valueOf(epochSecond));
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
private AuditService.AuditApplication findAuditAppById(String auditAppId)
{
    AuditService.AuditApplication auditApp = null;
    Map<String, AuditService.AuditApplication> auditApplicationsByName = auditService.getAuditApplications();
    if (auditApplicationsByName != null)
    {
        for (AuditService.AuditApplication auditApplication : auditApplicationsByName.values())
        {
            if (auditApplication.getKey().equals("/" + auditAppId))
            {
                auditApp = auditApplication;
            }
        }
    }
    return auditApp;
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
@Override
public AuditApp update(String auditAppId, AuditApp auditApp, Parameters parameters)
{
    checkEnabled();

    AuditService.AuditApplication auditApplication = findAuditAppByIdOr404(auditAppId);

    // Enable/Disable audit application
    if (auditApp.getIsEnabled() && !auditApplication.isEnabled())
    {
        auditService.enableAudit(auditApplication.getName(), null);
    }
    else if (!auditApp.getIsEnabled() && auditApplication.isEnabled())
    {
        auditService.disableAudit(auditApplication.getName(), null);
    }

    return new AuditApp(auditApplication.getKey().substring(1), auditApplication.getName(), auditApp.getIsEnabled());
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
@Before
public void setup() throws Exception 
{
    super.setup();

    permissionService = applicationContext.getBean("permissionService", PermissionService.class);
    authorityService = (AuthorityService) applicationContext.getBean("AuthorityService");
    auditService = applicationContext.getBean("AuditService", AuditService.class);

    AuditModelRegistryImpl auditModelRegistry = (AuditModelRegistryImpl) applicationContext.getBean("auditModel.modelRegistry");

    // Register the test model
    URL testModelUrl = ResourceUtils.getURL("classpath:alfresco/audit/alfresco-audit-access.xml");
    auditModelRegistry.registerModel(testModelUrl);
    auditModelRegistry.loadAuditModels();
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
protected PersonConsolidationAuditWorker(final NodeService nodeService, final AuditService auditService,
        final AuditComponent auditComponent, final int timeframeHours)
{
    this.nodeService = nodeService;
    this.auditService = auditService;
    this.auditComponent = auditComponent;
    this.timeframeHours = timeframeHours;
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
@Override
public AuditApp getAuditApp(String auditAppId, Parameters parameters)
{
    checkEnabled();

    AuditService.AuditApplication auditApplication = findAuditAppByIdOr404(auditAppId);

    return new AuditApp(auditApplication.getKey().substring(1), auditApplication.getName(), auditApplication.isEnabled());
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
private AuditService.AuditApplication findAuditAppByIdOr404(String auditAppId)
{
    AuditService.AuditApplication auditApplication = findAuditAppById(auditAppId);

    if (auditApplication == null)
    {
        throw new EntityNotFoundException(auditAppId);
    }

    return auditApplication;
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
@Override
public CollectionWithPagingInfo<AuditApp> getAuditApps(Paging paging)
{
    checkEnabled();

    Map<String, AuditService.AuditApplication> auditApplicationsByName = auditService.getAuditApplications();

    Set<String> audAppsName = new TreeSet<String>(auditApplicationsByName.keySet());
    Iterator<String> audAppsNameIt = audAppsName.iterator();

    int skipCount = paging.getSkipCount();
    int maxItems = paging.getMaxItems();
    int totalItems = audAppsName.size();
    int end = skipCount + maxItems;

    if (skipCount >= totalItems)
    {
        List<AuditApp> empty = Collections.emptyList();
        return CollectionWithPagingInfo.asPaged(paging, empty, false, totalItems);
    }

    List<AuditApp> auditApps = new ArrayList<AuditApp>(totalItems);
    int count = 0;
    for (int i = 0; i < end && audAppsNameIt.hasNext(); i++)
    {
        String auditAppName = audAppsNameIt.next();
        if (i < skipCount)
        {
            continue;
        }
        count++;
        AuditApplication auditApplication = auditApplicationsByName.get(auditAppName);

        auditApps.add(new AuditApp(auditApplication.getKey().substring(1), auditApplication.getName(), auditApplication.isEnabled()));
    }

    boolean hasMoreItems = (skipCount + count < totalItems);

    return CollectionWithPagingInfo.asPaged(paging, auditApps, hasMoreItems, totalItems);
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
@Override
public void deleteAuditEntry(String auditAppId, long auditEntryId, Parameters parameters)
{
    checkEnabled();

    AuditService.AuditApplication auditApplication = findAuditAppByIdOr404(auditAppId);

    int deleted = auditService.clearAuditByIdRange(auditApplication.getName(), auditEntryId, auditEntryId + 1);
    if (deleted != 1)
    {
        throw new EntityNotFoundException("" + auditEntryId);
    }
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
@Test
public void testGetApplications(){
	AuthenticationUtil.setAdminUserAsFullyAuthenticatedUser();
	AuditService.AuditApplication auditApp = scriptAuditService.getApplications().entrySet().iterator().next().getValue();

	Assert.assertTrue(auditApp.getKey().contains("/tagging"));
	Assert.assertTrue(auditApp.getName().contains("Alfresco Tagging Service"));
	Assert.assertTrue(auditApp.isEnabled()==true);

}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
@Override
public AuditService getAuditService()
{
    return (AuditService)getService(AUDIT_SERVICE);
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
/**
 * Sets the audit service.
 */
public void setAuditService(AuditService auditService)
{
    this.auditService = auditService;
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
@Override
public AuditService getAuditService()
{
    // A mock response
    return null;
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
@Override
protected void setUp() throws Exception
{
    // Detect any dangling transactions as there is a lot of direct UserTransaction manipulation
    if (AlfrescoTransactionSupport.getTransactionReadState() != TxnReadState.TXN_NONE)
    {
        throw new IllegalStateException(
                "There should not be any transactions when starting test: " +
                AlfrescoTransactionSupport.getTransactionId() + " started at " +
                new Date(AlfrescoTransactionSupport.getTransactionStartTime()));
    }
    
    // Get services
    this.taggingService = (TaggingService)ctx.getBean("TaggingService");
    this.nodeService = (NodeService) ctx.getBean("NodeService");
    this.contentService = (ContentService) ctx.getBean("ContentService");
    
    this.transactionService = (TransactionService)ctx.getBean("transactionComponent");
    this.auditService = (AuditService)ctx.getBean("auditService");
    this.authenticationComponent = (AuthenticationComponent)ctx.getBean("authenticationComponent");
    
    this.executer = (ContentMetadataExtracter) ctx.getBean("extract-metadata");
    executer.setEnableStringTagging(true);
    executer.setTaggingService(taggingService);
    
    if (init == false)
    {
        this.transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>(){

            @Override
            public Void execute() throws Throwable
            {
                // Authenticate as the system user
                authenticationComponent.setSystemUserAsCurrentUser();
                
                // Create the store and get the root node
                ContentMetadataExtracterTagMappingTest.storeRef = nodeService.createStore(StoreRef.PROTOCOL_WORKSPACE, "Test_" + System.currentTimeMillis());
                ContentMetadataExtracterTagMappingTest.rootNode = nodeService.getRootNode(ContentMetadataExtracterTagMappingTest.storeRef);
            
                // Create the required tagging category
                NodeRef catContainer = nodeService.createNode(ContentMetadataExtracterTagMappingTest.rootNode, ContentModel.ASSOC_CHILDREN, QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "categoryContainer"), ContentModel.TYPE_CONTAINER).getChildRef();        
                NodeRef catRoot = nodeService.createNode(
                        catContainer, 
                        ContentModel.ASSOC_CHILDREN, 
                        QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "categoryRoot"), 
                        ContentModel.TYPE_CATEGORYROOT).getChildRef();
                nodeService.createNode(
                       catRoot, 
                       ContentModel.ASSOC_CATEGORIES, 
                       ContentModel.ASPECT_TAGGABLE, 
                       ContentModel.TYPE_CATEGORY).getChildRef();
                
                MetadataExtracterRegistry registry = (MetadataExtracterRegistry) ctx.getBean("metadataExtracterRegistry");
                extractor = new TagMappingMetadataExtracter();
                extractor.setRegistry(registry);
                extractor.register();
                
                init = true;
                return null;
            }});
        
    }
    
    // We want to know when tagging actions have finished running
    asyncOccurs = (new TaggingServiceImplTest()).new AsyncOccurs();
    ((PolicyComponent)ctx.getBean("policyComponent")).bindClassBehaviour(
          AsynchronousActionExecutionQueuePolicies.OnAsyncActionExecute.QNAME,
          ActionModel.TYPE_ACTION,
          new JavaBehaviour(asyncOccurs, "onAsyncActionExecute", NotificationFrequency.EVERY_EVENT)
    );

    // We do want action tracking whenever the tag scope updater runs
    UpdateTagScopesActionExecuter updateTagsAction = 
        (UpdateTagScopesActionExecuter)ctx.getBean("update-tagscope");
    updateTagsAction.setTrackStatus(true);
}
 

import org.alfresco.service.cmr.audit.AuditService; //导入依赖的package包/类
/**
 * @param auditService
 *            the auditService to set
 */
public void setAuditService(final AuditService auditService)
{
    this.auditService = auditService;
}