Java QNameDAO类代码示例

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
@Before
public void setUp() throws Exception
{
    ctx = ApplicationContextHelper.getApplicationContext();
    this.modelValidator = (ModelValidator)ctx.getBean("modelValidator");
    this.dictionaryDAO = (DictionaryDAO)ctx.getBean("dictionaryDAO");
    this.qnameDAO = (QNameDAO)ctx.getBean("qnameDAO");
    this.namespaceDAO = (NamespaceDAO)ctx.getBean("namespaceDAO");
    this.nodeService = (NodeService)ctx.getBean("NodeService");
    this.fileFolderService = (FileFolderService)ctx.getBean("FileFolderService");
    this.contentService = (ContentService)ctx.getBean("contentService");
    this.versionService = (VersionService)ctx.getBean("VersionService");
    this.transactionService = (TransactionService)ctx.getBean("TransactionService");
    this.nodeArchiveService = (NodeArchiveService)ctx.getBean("nodeArchiveService");

    this.modelName = "modelvalidatortest" + System.currentTimeMillis();
    addModel();
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
public GetPeopleCannedQuery(
        NodeDAO nodeDAO,
        QNameDAO qnameDAO,
        CannedQueryDAO cannedQueryDAO,
        TenantService tenantService,
        NodeService nodeService,
        AuthorityService authorityService,
        CannedQueryParameters params)
{
    super(params);
    
    this.nodeDAO = nodeDAO;
    this.qnameDAO = qnameDAO;
    this.cannedQueryDAO = cannedQueryDAO;
    this.tenantService = tenantService;
    this.nodeService = nodeService;
    this.authorityService = authorityService;
    
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
@Override
public void prepare(NamespaceService namespaceService, DictionaryService dictionaryService, QNameDAO qnameDAO, NodeDAO nodeDAO, TenantService tenantService, Set<String> selectors, Map<String, Argument> functionArgs,  FunctionEvaluationContext functionContext, boolean supportBooleanFloatAndDouble)
{
    Function function = getFunction();
    if(function != null)
    {
        if(function instanceof DBQueryBuilderComponent)
        {
            DBQueryBuilderComponent dbQueryBuilderComponent = (DBQueryBuilderComponent)function;
            dbQueryBuilderComponent.prepare(namespaceService, dictionaryService, qnameDAO, nodeDAO, tenantService, selectors,  getFunctionArguments(), functionContext, supportBooleanFloatAndDouble);
        }
        else
        {
            throw new UnsupportedOperationException();
        }
    }
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
@Override
public void prepare(NamespaceService namespaceService, DictionaryService dictionaryService, QNameDAO qnameDAO, NodeDAO nodeDAO, TenantService tenantService, Set<String> selectors,
        Map<String, Argument> functionArgs, FunctionEvaluationContext functionContext, boolean supportBooleanFloatAndDouble)
{
    for (Constraint constraint : getConstraints())
    {
        if (constraint instanceof DBQueryBuilderComponent)
        {
            if(constraint.getOccur() == Occur.OPTIONAL)
            {
                throw new QueryModelException("Disjunctions are not suported");
            }
            DBQueryBuilderComponent dbQueryBuilderComponent = (DBQueryBuilderComponent) constraint;
            dbQueryBuilderComponent.prepare(namespaceService, dictionaryService, qnameDAO, nodeDAO, tenantService, selectors, functionArgs, functionContext, supportBooleanFloatAndDouble);
        }
        else
        {
            throw new UnsupportedOperationException();
        }
    }
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
@Override
public void prepare(NamespaceService namespaceService, DictionaryService dictionaryService, QNameDAO qnameDAO, NodeDAO nodeDAO, TenantService tenantService, Set<String> selectors,
        Map<String, Argument> functionArgs, FunctionEvaluationContext functionContext, boolean supportBooleanFloatAndDouble)
{
    //throw new QueryModelException("Disjunctions are not suported");
    
    for (Constraint constraint : getConstraints())
    {
        if (constraint instanceof DBQueryBuilderComponent)
        {
            DBQueryBuilderComponent dbQueryBuilderComponent = (DBQueryBuilderComponent) constraint;
            dbQueryBuilderComponent.prepare(namespaceService, dictionaryService, qnameDAO, nodeDAO, tenantService, selectors, functionArgs, functionContext, supportBooleanFloatAndDouble);
        }
        else
        {
            throw new UnsupportedOperationException();
        }
    }
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
public GetChildrenCannedQuery(
        NodeDAO nodeDAO,
        QNameDAO qnameDAO,
        CannedQueryDAO cannedQueryDAO,
        NodePropertyHelper nodePropertyHelper,
        TenantService tenantService,
        NodeService nodeService,
        MethodSecurityBean<NodeRef> methodSecurity,
        CannedQueryParameters params,
        HiddenAspect hiddenAspect,
        DictionaryService dictionaryService,
        Set<QName> ignoreAspectQNames)
{
    super(nodeDAO, qnameDAO, cannedQueryDAO, nodePropertyHelper, tenantService, nodeService, methodSecurity, params);
    
    this.hiddenAspect = hiddenAspect;
    this.dictionaryService = dictionaryService;
    
    this.nodeService = nodeService;
    this.ignoreAspectQNames = ignoreAspectQNames;
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
/**
 * Helper method to set the {@link #setTypeQNameId(Long)}.
 * 
 * @param qnameDAO                  the DAO to resolve the QName ID
 * @param typeQName                 the association type
 * @param forUpdate                 <tt>true</tt> if the QName must exist i.e. this
 *                                  entity will be used for updates and the type
 *                                  <code>QName</code> <b>must</b> exist.
 * @return                          <tt>true</tt> if the set worked otherwise <tt>false</tt>
 */
public boolean setTypeQNameAll(QNameDAO qnameDAO, QName typeQName, boolean forUpdate)
{
    if (forUpdate)
    {
        typeQNameId = qnameDAO.getOrCreateQName(typeQName).getFirst();
        return true;
    }
    else
    {
        Pair<Long, QName> qnamePair = qnameDAO.getQName(typeQName);
        if (qnamePair == null)
        {
            return false;
        }
        else
        {
            typeQNameId = qnamePair.getFirst();
            return true;
        }
    }
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
@Override
public void setUp() throws Exception
{
    ServiceRegistry serviceRegistry = (ServiceRegistry) ctx.getBean(ServiceRegistry.SERVICE_REGISTRY);
    transactionService = serviceRegistry.getTransactionService();
    txnHelper = transactionService.getRetryingTransactionHelper();

    solrTrackingComponent = (SOLRTrackingComponent) ctx.getBean("solrTrackingComponent");
    nodeDAO = (NodeDAO)ctx.getBean("nodeDAO");
    qnameDAO = (QNameDAO) ctx.getBean("qnameDAO");
    dictionaryDAO =  (DictionaryDAO)ctx.getBean("dictionaryDAO");
    nodeService = (NodeService)ctx.getBean("NodeService");
    fileFolderService = (FileFolderService)ctx.getBean("FileFolderService");
    dictionaryService = serviceRegistry.getDictionaryService();
    namespaceService = serviceRegistry.getNamespaceService();
    authenticationComponent = (AuthenticationComponent)ctx.getBean("authenticationComponent");

    dbNodeService = (DbNodeServiceImpl)ctx.getBean("dbNodeService");
    dbNodeService.setEnableTimestampPropagation(false);

    authenticationComponent.setSystemUserAsCurrentUser();

    storeRef = nodeService.createStore(StoreRef.PROTOCOL_WORKSPACE, getName() + System.currentTimeMillis());
    rootNodeRef = nodeService.getRootNode(storeRef);
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
SOLRTest(
    RetryingTransactionHelper txnHelper, FileFolderService fileFolderService,
    NodeDAO nodeDAO, QNameDAO qnameDAO, NodeService nodeService, DictionaryService dictionaryService,
    NodeRef rootNodeRef, String containerName, boolean doNodeChecks, boolean doMetaDataChecks)
    {
this.txnHelper = txnHelper;
this.nodeService = nodeService;
this.rootNodeRef = rootNodeRef;
this.fileFolderService = fileFolderService;
this.nodeDAO = nodeDAO;
this.qnameDAO = qnameDAO;
this.dictionaryService = dictionaryService;

this.containerName = containerName;
this.nodeAssertions = new HashMap<NodeRef, NodeAssertions>();
this.nodeIds = new ArrayList<Long>(getExpectedNumNodes());

this.doNodeChecks = doNodeChecks;
this.doMetaDataChecks = doMetaDataChecks;
this.doChecks = doNodeChecks || doMetaDataChecks;
    }
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
SOLRTestResidualProperties(
    RetryingTransactionHelper txnHelper, FileFolderService fileFolderService,
    NodeDAO nodeDAO, QNameDAO qnameDAO, NodeService nodeService, DictionaryService dictionaryService,
    NodeRef rootNodeRef, String containerName, boolean doNodeChecks, boolean doMetaDataChecks)
    {
super(txnHelper, fileFolderService, nodeDAO, qnameDAO, nodeService, dictionaryService,rootNodeRef, containerName, doNodeChecks, doMetaDataChecks);
    }
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
@Override
public void setUp()
{
    ServiceRegistry serviceRegistry = (ServiceRegistry) ctx.getBean(ServiceRegistry.SERVICE_REGISTRY);
    DictionaryService dictionaryService = serviceRegistry.getDictionaryService();
    QNameDAO qnameDAO = (QNameDAO) ctx.getBean("qnameDAO");
    LocaleDAO localeDAO = (LocaleDAO) ctx.getBean("localeDAO");
    ContentDataDAO contentDataDAO = (ContentDataDAO) ctx.getBean("contentDataDAO");

    helper = new NodePropertyHelper(dictionaryService, qnameDAO, localeDAO, contentDataDAO);
    transactionService = serviceRegistry.getTransactionService();
    txnHelper = transactionService.getRetryingTransactionHelper();
    txnHelper.setMinRetryWaitMs(10);
    txnHelper.setRetryWaitIncrementMs(10);
    txnHelper.setMaxRetryWaitMs(50);
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
@Before
public void setUp() throws Exception
{
    this.modelValidator = (ModelValidator)ctx.getBean("modelValidator");
    this.dictionaryDAO = (DictionaryDAO)ctx.getBean("dictionaryDAO");
    this.qnameDAO = (QNameDAO)ctx.getBean("qnameDAO");
    this.namespaceDAO = (NamespaceDAO)ctx.getBean("namespaceDAO");
    this.nodeService = (NodeService)ctx.getBean("NodeService");
    this.fileFolderService = (FileFolderService)ctx.getBean("FileFolderService");
    this.contentService = (ContentService)ctx.getBean("contentService");
    this.versionService = (VersionService)ctx.getBean("VersionService");
    this.transactionService = (TransactionService)ctx.getBean("TransactionService");
    this.nodeArchiveService = (NodeArchiveService)ctx.getBean("nodeArchiveService");

    this.modelName = "modelvalidatortest" + System.currentTimeMillis();
    addModel();
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
@Override
public void prepare(NamespaceService namespaceService, DictionaryService dictionaryService, QNameDAO qnameDAO, NodeDAO nodeDAO, TenantService tenantService, Set<String> selectors,
        Map<String, Argument> functionArgs, FunctionEvaluationContext functionContext, boolean supportBooleanFloatAndDouble)
{
    Argument argument = functionArgs.get(ARG_TERM);
    String term = (String) argument.getValue(functionContext);
    // strip trailing wildcard *
    term = term.substring(0, term.length() - 1);
    PropertyArgument propertyArgument = (PropertyArgument) functionArgs.get(ARG_PROPERTY);

    argument = functionArgs.get(ARG_TOKENISATION_MODE);
    AnalysisMode mode = (AnalysisMode) argument.getValue(functionContext);
    if (mode != AnalysisMode.IDENTIFIER)
    {
        throw new QueryModelException("Analysis mode not supported for DB " + mode);
    }

    PropertySupport propertySupport = new PropertySupport();
    propertySupport.setValue(term + "%");

    QName propertyQName = QName.createQName(DBQuery.expandQName(functionContext.getAlfrescoPropertyName(propertyArgument.getPropertyName()), namespaceService));
    propertySupport.setPropertyQName(propertyQName);
    propertySupport.setPropertyDataType(DBQuery.getDataTypeDefinition(dictionaryService, propertyQName));
    propertySupport.setPair(qnameDAO.getQName(propertyQName));
    propertySupport.setJoinCommandType(DBQuery.getJoinCommandType(propertyQName));
    propertySupport.setFieldName(DBQuery.getFieldName(dictionaryService, propertyQName, supportBooleanFloatAndDouble));
    propertySupport.setCommandType(DBQueryBuilderPredicatePartCommandType.LIKE);
    builderSupport = propertySupport;

}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
@Override
public void prepare(NamespaceService namespaceService, DictionaryService dictionaryService, QNameDAO qnameDAO, NodeDAO nodeDAO, TenantService tenantService, Set<String> selectors,
        Map<String, Argument> functionArgs, FunctionEvaluationContext functionContext, boolean supportBooleanFloatAndDouble)
{
    // TODO Auto-generated method stub
    
}
 

import org.alfresco.repo.domain.qname.QNameDAO; //导入依赖的package包/类
@Override
public void prepare(NamespaceService namespaceService, DictionaryService dictionaryService, QNameDAO qnameDAO, NodeDAO nodeDAO, TenantService tenantService, Set<String> selectors, Map<String, Argument> functionArgs, FunctionEvaluationContext functionContext, boolean supportBooleanFloatAndDouble)
{
   
    Argument argument = functionArgs.get(ARG_PARENT);
    String id = (String) argument.getValue(functionContext);
    argument = functionArgs.get(ARG_SELECTOR);
    if(argument != null)
    {
        String selector = (String) argument.getValue(functionContext);
        if(!selectors.contains(selector))
        {
            throw new QueryModelException("Unkown selector "+selector); 
        }
    }
    else
    {
        if(selectors.size() > 1)
        {
            throw new QueryModelException("Selector must be specified for child constraint (IN_FOLDER) and join"); 
        }
    }
    ParentSupport parentSupport = new ParentSupport();
    parentSupport.setDbid(DBQuery.getDbid(id, nodeDAO, tenantService));
    parentSupport.setCommandType(DBQueryBuilderPredicatePartCommandType.EQUALS);
    builderSupport = parentSupport;
}