Attachment #123622 for bug #216053

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 216053
Collapse All | Expand All




    }
    
    @Override public ErrorDescription[] apply(TypeElement subject, ProblemContext ctx){
        long start  = System.nanoTime();
        Object modEl = ctx.getModelElement();
        Entity entity = (Entity) (modEl instanceof Entity ? modEl : null);
        List<AnnotationMirror> first = Utilities.findAnnotations(subject, JPAAnnotations.NAMED_QUERY);

        JPQLQueryHelper helper = new JPQLQueryHelper();
        Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
        List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();
        ManagedTypeProvider mtp = new ManagedTypeProvider(project, ((JPAProblemContext)ctx).getMetaData());
        for(int index=0;index<values.size();index++){
            String value = values.get(index);
            String qName = names.get(index);

                nq.setQuery(value);
                nq.setName(qName);
            }
            helper.setQuery(new Query(nq, value, mtp));
            List<JPQLQueryProblem> tmp = null;
            try{
                tmp = helper.validate();

            }
            if(tmp!=null && tmp.size()>0)problems.addAll(tmp);
            helper.dispose();
            System.out.println("TIME TO COMPLETE: "+(System.nanoTime() - start));
        }
        if (problems != null && problems.size()>0){
            ErrorDescription[] ret = new ErrorDescription[problems.size()];

Lines 153-159 Link Here

(-)a/j2ee.jpa.verification/src/org/netbeans/modules/j2ee/jpa/verification/rules/entity/JPQLValidation.java (-1 / +1 lines)
153	}	153	}
154	if(tmp!=null && tmp.size()>0)problems.addAll(tmp);	154	if(tmp!=null && tmp.size()>0)problems.addAll(tmp);
155	helper.dispose();	155	helper.dispose();
156	System.out.println("TIME TO COMPLETE: "+(System.nanoTime() - start));	156	//System.out.println("TIME TO COMPLETE: "+(System.nanoTime() - start));
157	}	157	}
158	if (problems != null && problems.size()>0){	158	if (problems != null && problems.size()>0){
159	ErrorDescription[] ret = new ErrorDescription[problems.size()];	159	ErrorDescription[] ret = new ErrorDescription[problems.size()];




 */
public class TypeRepository implements ITypeRepository {
    private final Project project;
    private final Map<String, IType[]> types;
    private PUDataObject dObj;
    private MetadataModelReadHelper<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>> readHelper;

    TypeRepository(Project project){
        this.project = project;
        types = new HashMap<String, IType[]>();
    }
    
    @Override
    public IType getEnumType(String fqn) {
        System.out.println("ENUM: "+fqn);
        IType[] ret = types.get(fqn);
        if(ret == null){
            fillTypeElement(fqn);
            ret = types.get(fqn);
        }
        return ret[0];
    }

    @Override
    public IType getType(Class<?> type) {
        String fqn = type.getCanonicalName();
        System.out.println("TYPECL: "+fqn);
        IType[] ret = types.get(fqn);
        if(ret == null){
            fillTypeElement(type);
            ret = types.get(fqn);
        }
        return ret[0];
    }

    @Override
    public IType getType(String fqn) {
        System.out.println("TYPEFQ: "+fqn);
        IType[] ret = types.get(fqn);
        if(ret == null){
            if(IType.UNRESOLVABLE_TYPE.equals(fqn)){
                types.put(fqn, new Type[] {new Type(this, fqn)});
            } else {
                fillTypeElement(fqn);
            }
            ret = types.get(fqn);
        }
        return ret[0];
    }

    @Override

    }
    
    private void fillTypeElement(final String fqn){
        System.out.println("FILL FQN: "+fqn);
        Sources sources=ProjectUtils.getSources(project);
        SourceGroup groups[]=sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
        types.put(fqn, new Type[]{null});
        if(groups != null && groups.length>0){
            SourceGroup firstGroup=groups[0];
            FileObject fo=firstGroup.getRootFolder();

                    @Override
                    public void run(WorkingCopy wc) throws Exception {
                        TypeElement te = wc.getElements().getTypeElement(fqn);
                        if(te!=null) types.put(fqn, new Type[]{new Type(TypeRepository.this, te)});
                    }
                });
            } catch (IOException ex) {

        }
    }
    private void fillTypeElement(Class<?> type){
        types.put(type.getName(), new Type[]{new Type(TypeRepository.this, type)});
    }
    
}




    
    @Override
    public IType getEnumType(String fqn) {
        System.out.println("ENUM: "+fqn);
        IType[] ret = types.get(fqn);
        if(ret == null){
            fillTypeElement(fqn);

    @Override
    public IType getType(Class<?> type) {
        String fqn = type.getCanonicalName();
        System.out.println("TYPECL: "+fqn);
        IType[] ret = types.get(fqn);
        if(ret == null){
            fillTypeElement(type);


    @Override
    public IType getType(String fqn) {
        System.out.println("TYPEFQ: "+fqn);
        IType[] ret = types.get(fqn);
        if(ret == null){
            if(IType.UNRESOLVABLE_TYPE.equals(fqn)){

    }
    
    private void fillTypeElement(final String fqn){
        System.out.println("FILL FQN: "+fqn);
        Sources sources=ProjectUtils.getSources(project);
        SourceGroup groups[]=sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
        types.put(fqn, new Type[]{null});




import org.eclipse.persistence.jpa.internal.jpql.JPQLQueryProblemResourceBundle;
import org.eclipse.persistence.jpa.jpql.JPQLQueryHelper;
import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem;
import org.eclipse.persistence.jpa.jpql.spi.IQuery;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.modules.j2ee.jpa.model.JPAAnnotations;

 * Verify content of @NamedQuery query
 * TODO: good to move warning to query level instead of class level
 */
public class JPQLValidation extends JPAClassRule{
    
    /** Creates a new instance of NonFinalClass */
    public JPQLValidation() {

    }
    
    @Override public ErrorDescription[] apply(TypeElement subject, ProblemContext ctx){
        long start  = System.nanoTime();
        Object modEl = ctx.getModelElement();
        Entity entity = (Entity) (modEl instanceof Entity ? modEl : null);
        List<AnnotationMirror> first = Utilities.findAnnotations(subject, JPAAnnotations.NAMED_QUERY);

        Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
        List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();
        ManagedTypeProvider mtp = new ManagedTypeProvider(project, ((JPAProblemContext)ctx).getMetaData());
        for(int index=0;index<values.size() && !ctx.isCancelled();index++){
            String value = values.get(index);
            String qName = names.get(index);
            NamedQuery nq = null;

            }
            if(tmp!=null && tmp.size()>0)problems.addAll(tmp);
            helper.dispose();
            //System.out.println("TIME TO COMPLETE: "+(System.nanoTime() - start));
        }
        if (!ctx.isCancelled() && problems != null && problems.size()>0){
            ErrorDescription[] ret = new ErrorDescription[problems.size()];
            for(int i=0;i<ret.length;i++){
                ListResourceBundle msgBundle = null;

Lines 1-6 Link Here

(-)a/j2ee.jpa.verification/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.j2ee.jpa.verification	2	OpenIDE-Module: org.netbeans.modules.j2ee.jpa.verification
3	OpenIDE-Module-Specification-Version: 1.22	3	OpenIDE-Module-Specification-Version: 1.22.1
4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/j2ee/jpa/verification/Bundle.properties	4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/j2ee/jpa/verification/Bundle.properties
5	AutoUpdate-Show-In-Client: false	5	AutoUpdate-Show-In-Client: false
6		6

Lines 71-77 Link Here

(-)a/j2ee.jpa.verification/nbproject/project.xml (-1 / +1 lines)
71	<build-prerequisite/>	71	<build-prerequisite/>
72	<compile-dependency/>	72	<compile-dependency/>
73	<run-dependency>	73	<run-dependency>
74	<specification-version>1.29</specification-version>	74	<specification-version>1.31.1</specification-version>
75	</run-dependency>	75	</run-dependency>
76	</dependency>	76	</dependency>
77	<dependency>	77	<dependency>




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.j2ee.jpa.verification;

/**
 * handle verification cancelling with this interface
 * @author sp153251
 */
public interface CancelListener {
    void cancelled();
}

Lines 44-49 Link Here

(-)a/j2ee.jpa.verification/src/org/netbeans/modules/j2ee/jpa/verification/JPAProblemContext.java (+26 lines)
44		44
45	package org.netbeans.modules.j2ee.jpa.verification;	45	package org.netbeans.modules.j2ee.jpa.verification;
46		46
		47	import java.util.HashSet;
		48	import java.util.Set;
47	import org.netbeans.modules.j2ee.jpa.model.AccessType;	49	import org.netbeans.modules.j2ee.jpa.model.AccessType;
48	import org.netbeans.modules.j2ee.jpa.verification.common.ProblemContext;	50	import org.netbeans.modules.j2ee.jpa.verification.common.ProblemContext;
49	import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;	51	import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;
Lines 60-65 Link Here
60	private boolean mappedSuperClass;	62	private boolean mappedSuperClass;
61	private AccessType accessType;	63	private AccessType accessType;
62	private EntityMappingsMetadata metadata;	64	private EntityMappingsMetadata metadata;
		65	private Set<CancelListener> cListeners;
63		66
64	public boolean isEntity(){	67	public boolean isEntity(){
65	return entity;	68	return entity;
Lines 112-115 Link Here
112	public boolean isJPAClass(){	115	public boolean isJPAClass(){
113	return entity \|\| embeddable \|\| idClass \|\| mappedSuperClass;	116	return entity \|\| embeddable \|\| idClass \|\| mappedSuperClass;
114	}	117	}
		118
		119	@Override
		120	public void setCancelled(boolean cancelled) {
		121	super.setCancelled(cancelled);
		122	if(cancelled && cListeners != null) {
		123	for(CancelListener cl:cListeners) {
		124	cl.cancelled();
		125	}
		126	}
		127	}
		128
		129	public void addCancelListener(CancelListener aThis) {
		130	if(cListeners == null) {
		131	cListeners = new HashSet();
		132	}
		133	cListeners.add(aThis);
		134	}
		135
		136	public void removeCancelListener(CancelListener cl) {
		137	if(cListeners != null) {
		138	cListeners.remove(cl);
		139	}
		140	}
115	}	141	}

Lines 63-68 Link Here

(-)a/j2ee.jpa.verification/src/org/netbeans/modules/j2ee/jpa/verification/rules/entity/JPQLValidation.java (-5 / +17 lines)
63	import org.netbeans.api.project.FileOwnerQuery;	63	import org.netbeans.api.project.FileOwnerQuery;
64	import org.netbeans.api.project.Project;	64	import org.netbeans.api.project.Project;
65	import org.netbeans.modules.j2ee.jpa.model.JPAAnnotations;	65	import org.netbeans.modules.j2ee.jpa.model.JPAAnnotations;
		66	import org.netbeans.modules.j2ee.jpa.verification.CancelListener;
66	import org.netbeans.modules.j2ee.jpa.verification.JPAClassRule;	67	import org.netbeans.modules.j2ee.jpa.verification.JPAClassRule;
67	import org.netbeans.modules.j2ee.jpa.verification.JPAClassRule.ClassConstraints;	68	import org.netbeans.modules.j2ee.jpa.verification.JPAClassRule.ClassConstraints;
68	import org.netbeans.modules.j2ee.jpa.verification.JPAProblemContext;	69	import org.netbeans.modules.j2ee.jpa.verification.JPAProblemContext;
Lines 80-86 Link Here
80	* Verify content of @NamedQuery query	81	* Verify content of @NamedQuery query
81	* TODO: good to move warning to query level instead of class level	82	* TODO: good to move warning to query level instead of class level
82	*/	83	*/
83	public class JPQLValidation extends JPAClassRule{	84	public class JPQLValidation extends JPAClassRule implements CancelListener{
		85
		86	private ManagedTypeProvider mtp;//need to store as jpql validation may be too long and need to be cancelled if required
84		87
85	/** Creates a new instance of NonFinalClass */	88	/** Creates a new instance of NonFinalClass */
86	public JPQLValidation() {	89	public JPQLValidation() {
Lines 90-95 Link Here
90	}	93	}
91		94
92	@Override public ErrorDescription[] apply(TypeElement subject, ProblemContext ctx){	95	@Override public ErrorDescription[] apply(TypeElement subject, ProblemContext ctx){
		96	JPAProblemContext jpaCtx = (JPAProblemContext)ctx;
		97	jpaCtx.addCancelListener(this);
93	Object modEl = ctx.getModelElement();	98	Object modEl = ctx.getModelElement();
94	Entity entity = (Entity) (modEl instanceof Entity ? modEl : null);	99	Entity entity = (Entity) (modEl instanceof Entity ? modEl : null);
95	List<AnnotationMirror> first = Utilities.findAnnotations(subject, JPAAnnotations.NAMED_QUERY);	100	List<AnnotationMirror> first = Utilities.findAnnotations(subject, JPAAnnotations.NAMED_QUERY);
Lines 130-136 Link Here
130	JPQLQueryHelper helper = new JPQLQueryHelper();	135	JPQLQueryHelper helper = new JPQLQueryHelper();
131	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());	136	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
132	List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();	137	List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();
133	ManagedTypeProvider mtp = new ManagedTypeProvider(project, ((JPAProblemContext)ctx).getMetaData());	138	mtp = new ManagedTypeProvider(project, jpaCtx.getMetaData());
134	for(int index=0;index<values.size() && !ctx.isCancelled();index++){	139	for(int index=0;index<values.size() && !ctx.isCancelled();index++){
135	String value = values.get(index);	140	String value = values.get(index);
136	String qName = names.get(index);	141	String qName = names.get(index);
Lines 152-159 Link Here
152	if(tmp!=null && tmp.size()>0)problems.addAll(tmp);	157	if(tmp!=null && tmp.size()>0)problems.addAll(tmp);
153	helper.dispose();	158	helper.dispose();
154	}	159	}
		160	ErrorDescription[] ret = null;
155	if (!ctx.isCancelled() && problems != null && problems.size()>0){	161	if (!ctx.isCancelled() && problems != null && problems.size()>0){
156	ErrorDescription[] ret = new ErrorDescription[problems.size()];	162	ret = new ErrorDescription[problems.size()];
157	for(int i=0;i<ret.length;i++){	163	for(int i=0;i<ret.length;i++){
158	ListResourceBundle msgBundle = null;	164	ListResourceBundle msgBundle = null;
159	try{	165	try{
Lines 169-177 Link Here
169	}	175	}
170	ret[i] = createProblem(subject, ctx, pos + ": " + message , Severity.WARNING);	176	ret[i] = createProblem(subject, ctx, pos + ": " + message , Severity.WARNING);
171	}	177	}
172	return ret;
173	}	178	}
174	return null;	179	jpaCtx.removeCancelListener(this);
		180	mtp = null;
		181	return ret;
175	}	182	}
176		183
177	@Override protected boolean isApplicable(TypeElement subject, ProblemContext ctx) {	184	@Override protected boolean isApplicable(TypeElement subject, ProblemContext ctx) {
Lines 179-182 Link Here
179		186
180	return (jpaCtx.isEntity() \|\| jpaCtx.isMappedSuperClass());	187	return (jpaCtx.isEntity() \|\| jpaCtx.isMappedSuperClass());
181	}	188	}
		189
		190	@Override
		191	public void cancelled() {
		192	if(mtp != null)mtp.invalidate();
		193	}
182	}	194	}

Lines 41-47 Link Here

(-)a/j2ee.persistence/nbproject/project.properties (-1 / +1 lines)
41	# made subject to such option by the copyright holder.	41	# made subject to such option by the copyright holder.
42		42
43	javac.source=1.6	43	javac.source=1.6
44	spec.version.base=1.31.0	44	spec.version.base=1.31.1
45		45
46	test.unit.run.cp.extra=${j2eeserver.dir}/modules/ext/jsr88javax.jar:${j2ee.persistence.dir}/modules/ext/eclipselink/eclipselink-2.3.2.jar:${j2ee.persistence.dir}/modules/ext/eclipselink/javax.persistence-2.0.3.jar:${masterfs.dir}/modules/org-netbeans-modules-masterfs.jar	46	test.unit.run.cp.extra=${j2eeserver.dir}/modules/ext/jsr88javax.jar:${j2ee.persistence.dir}/modules/ext/eclipselink/eclipselink-2.3.2.jar:${j2ee.persistence.dir}/modules/ext/eclipselink/javax.persistence-2.0.3.jar:${masterfs.dir}/modules/org-netbeans-modules-masterfs.jar
47		47




 */
package org.netbeans.modules.j2ee.persistence.spi.jpql;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.eclipse.persistence.jpa.jpql.spi.IEntity;
import org.eclipse.persistence.jpa.jpql.spi.IJPAVersion;
import org.eclipse.persistence.jpa.jpql.spi.IManagedType;

import org.eclipse.persistence.jpa.jpql.spi.IType;
import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;
import org.netbeans.api.project.Project;
import org.netbeans.modules.j2ee.metadata.model.api.MetadataModel;
import org.netbeans.modules.j2ee.metadata.model.api.MetadataModelAction;
import org.netbeans.modules.j2ee.persistence.api.EntityClassScope;
import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappings;
import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;
import org.netbeans.modules.j2ee.persistence.dd.PersistenceUtils;
import org.netbeans.modules.j2ee.persistence.util.MetadataModelReadHelper;
import org.netbeans.modules.j2ee.persistence.wizard.EntityClosure;
import org.openide.util.Exceptions;

/**
 *

    private Map<String, IManagedType> managedTypes;
    private ITypeRepository typeRepository;
    private final EntityMappings mappings;
    private boolean valid = true;//used to conrol long tasks, if not valid long tasks should be either terminated or goes short way

    public ManagedTypeProvider(Project project, EntityMappingsMetadata metaData) {
        this.project = project;

    @Override
    public ITypeRepository getTypeRepository() {
        if (typeRepository == null) {
            typeRepository = new TypeRepository(project, this);
        }
        return typeRepository;
    }

        initializeManagedTypes();
        return Collections.unmodifiableCollection(managedTypes.values());
    }
    
    public boolean isValid() {
        return valid;
    }
    
    /**
     * make model invalid and it shoul case processing to stop, minimize etc.
     * results with SPI may not be consider valid if provider isn't valid
     */
    public void invalidate() {
        valid = false;
        //TODO: may have sense to clean stored data
    }

    private void initializeManagedTypes() {
        if (managedTypes == null) {




    private final Map<String, IType[]> types;
    private PUDataObject dObj;
    private MetadataModelReadHelper<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>> readHelper;
    private final ManagedTypeProvider mtp;


    TypeRepository(Project project, ManagedTypeProvider mtp) {
        this.project = project;
        this.mtp = mtp;
        types = new HashMap<String, IType[]>();
    }
    

        Sources sources=ProjectUtils.getSources(project);
        SourceGroup groups[]=sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
        types.put(fqn, new Type[]{null});
        if(mtp.isValid() && groups != null && groups.length>0){
            SourceGroup firstGroup=groups[0];
            FileObject fo=firstGroup.getRootFolder();
            ClasspathInfo classpathInfo = ClasspathInfo.create(fo);

                javaSource.runModificationTask(new Task<WorkingCopy>() {
                    @Override
                    public void run(WorkingCopy wc) throws Exception {
                        if(mtp.isValid()) {//model will be filled with nulls  after provider invalidation and with values only if valid provider
                            TypeElement te = wc.getElements().getTypeElement(fqn);
                            if(te!=null) {
                                types.put(fqn, new Type[]{new Type(TypeRepository.this, te)});
                            }
                        }
                    }
                });
            } catch (IOException ex) {




    public IType getEnumType(String fqn) {
        IType[] ret = types.get(fqn);
        if(ret == null){
            //get main type
            int lastPoint = fqn.lastIndexOf('.');
            String mainPart = lastPoint > 0 ? fqn.substring(0, lastPoint) : null;
            if(mainPart != null){
                IType[] mainType = types.get(mainPart);
                if(mainType == null){
                    fillTypeElement(mainPart);
                }
                mainType = types.get(mainPart);
                if(mainType[0] != null){
                    fillTypeElement(fqn);
                } else {
                    types.put(fqn, new Type[]{null});
                }
            } else {
                //shouldn't happens
                fillTypeElement(fqn);
            }
            ret = types.get(fqn);
        }
        return ret[0];




    private void initializeManagedTypes() {
        if (managedTypes == null) {
            managedTypes = new HashMap<String, IManagedType>();
            //TODO fill
//            EntityClassScope entityClassScope = EntityClassScope.getEntityClassScope(project.getProjectDirectory());
//            MetadataModel<EntityMappingsMetadata> model = entityClassScope.getEntityMappingsModel(true);
//            MetadataModelReadHelper<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>> readHelper = MetadataModelReadHelper.create(model, new MetadataModelAction<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>>() {
//
//                @Override
//                public List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity> run(EntityMappingsMetadata metadata) {
//                    return Arrays.asList(metadata.getRoot().getEntity());
//                }
//            });
//            List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity> entities = null;
//            try {
//                entities = readHelper.getResult();
//            } catch (ExecutionException ex) {
//                Exceptions.printStackTrace(ex);
//            }

            //TODO: not only entities but mapped superclasses and embeddable?
            for (org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity persistentType : mappings.getEntity()) {


Lines 238-244 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/Type.java (-1 / +3 lines)
238		238
239	TypeElement tmpEl = el;	239	TypeElement tmpEl = el;
240	while(tmpEl != null){	240	while(tmpEl != null){
241	if(tmpEl.getQualifiedName().toString().equals(name)) return true;	241	if(tmpEl.getQualifiedName().contentEquals(name)) {
		242	return true;
		243	}
242	else {	244	else {
243	TypeMirror supMirror = tmpEl.getSuperclass();	245	TypeMirror supMirror = tmpEl.getSuperclass();
244	if (supMirror.getKind() == TypeKind.DECLARED) {	246	if (supMirror.getKind() == TypeKind.DECLARED) {




import java.util.Map;
import javax.lang.model.element.TypeElement;
import org.eclipse.persistence.jpa.jpql.TypeHelper;
import org.eclipse.persistence.jpa.jpql.spi.IManagedType;
import org.eclipse.persistence.jpa.jpql.spi.IType;
import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;
import org.netbeans.api.java.project.JavaProjectConstants;

            if(IType.UNRESOLVABLE_TYPE.equals(fqn)){
                types.put(fqn, new Type[] {new Type(this, fqn)});
            } else {
                //try to find in managed
                int lastPnt = fqn.lastIndexOf('.');
                ManagedType mt = (ManagedType) (lastPnt > -1 ? mtp.getManagedType(fqn.substring(lastPnt+1)) :  mtp.getManagedType(fqn));
                if(mt != null  && mt.getPersistentObject() != null && mt.getPersistentObject().getTypeElement()!=null && mt.getPersistentObject().getTypeElement().getQualifiedName().contentEquals(fqn)) {
                    TypeElement te = mt.getPersistentObject().getTypeElement();
                    types.put(fqn, new Type[]{new Type(TypeRepository.this, te)});
                } else {
                    //
                    fillTypeElement(fqn);
                }
            }
            ret = types.get(fqn);
        }

Lines 56-61 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/Type.java (-11 / +28 lines)
56	import org.eclipse.persistence.jpa.jpql.spi.IType;	56	import org.eclipse.persistence.jpa.jpql.spi.IType;
57	import org.eclipse.persistence.jpa.jpql.spi.ITypeDeclaration;	57	import org.eclipse.persistence.jpa.jpql.spi.ITypeDeclaration;
58	import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;	58	import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;
		59	import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.PersistentObject;
59		60
60	/**	61	/**
61	*	62	*
Lines 64-69 Link Here
64	public class Type implements IType{	65	public class Type implements IType{
65		66
66	private final Element element;	67	private final Element element;
		68	private PersistentObject po;
67	private final ITypeRepository repository;	69	private final ITypeRepository repository;
68	private ITypeDeclaration tDeclaration;	70	private ITypeDeclaration tDeclaration;
69	private final Class<?> type;	71	private final Class<?> type;
Lines 71-76 Link Here
71	private String[] enumConstants;	73	private String[] enumConstants;
72	private String typeName;	74	private String typeName;
73		75
		76	public Type(ITypeRepository typeRepository, PersistentObject po) {
		77	element = null;
		78	this.po = po;
		79	this.repository = typeRepository;
		80	type = null;
		81	}
		82
74	public Type(ITypeRepository typeRepository, Element element){	83	public Type(ITypeRepository typeRepository, Element element){
75	this.element = element;	84	this.element = element;
76	this.repository = typeRepository;	85	this.repository = typeRepository;
Lines 97-103 Link Here
97	public Iterable<IConstructor> constructors() {	106	public Iterable<IConstructor> constructors() {
98	if(constructors == null){	107	if(constructors == null){
99	constructors = new ArrayList<IConstructor>();	108	constructors = new ArrayList<IConstructor>();
100	if(element != null){	109	if(po!=null) {
		110	collectConstructors(constructors, po.getTypeElement());
		111	} else if(element != null){
101	collectConstructors(constructors, element);	112	collectConstructors(constructors, element);
102	} else if (type != null) {	113	} else if (type != null) {
103	collectConstructors(constructors, type);	114	collectConstructors(constructors, type);
Lines 124-132 Link Here
124	@Override	135	@Override
125	public String[] getEnumConstants() {	136	public String[] getEnumConstants() {
126	if(enumConstants == null){	137	if(enumConstants == null){
127	if(element != null){	138	Element elt = po != null ? po.getTypeElement() : element;
		139	if(elt != null){
128	ArrayList<String> constants = new ArrayList<String>();	140	ArrayList<String> constants = new ArrayList<String>();
129	for( Element el:element.getEnclosedElements() ){	141	for( Element el:elt.getEnclosedElements() ){
130	if(el.getKind() == ElementKind.ENUM_CONSTANT){	142	if(el.getKind() == ElementKind.ENUM_CONSTANT){
131	constants.add(el.getSimpleName().toString());	143	constants.add(el.getSimpleName().toString());
132	}	144	}
Lines 154-162 Link Here
154	@Override	166	@Override
155	public String getName() {	167	public String getName() {
156	if(typeName == null){	168	if(typeName == null){
157	if(element != null){	169	Element elt = po != null ? po.getTypeElement() : element;
158	if(element instanceof TypeElement) typeName = ((TypeElement) element).getQualifiedName().toString();	170	if(elt != null){
159	else typeName = element.asType().toString();	171	if(elt instanceof TypeElement) typeName = ((TypeElement) elt).getQualifiedName().toString();
		172	else typeName = elt.asType().toString();
160	} else if (type != null) {	173	} else if (type != null) {
161	typeName = type.getName();	174	typeName = type.getName();
162	}	175	}
Lines 174-190 Link Here
174		187
175	@Override	188	@Override
176	public boolean hasAnnotation(Class<? extends Annotation> type) {	189	public boolean hasAnnotation(Class<? extends Annotation> type) {
177	return element != null ? (element.getAnnotation(type) != null) : (type!=null && type.isAnnotationPresent(type));	190	Element elt = po != null ? po.getTypeElement() : element;
		191	return elt != null ? (elt.getAnnotation(type) != null) : (type!=null && type.isAnnotationPresent(type));
178	}	192	}
179		193
180	@Override	194	@Override
181	public boolean isAssignableTo(IType itype) {	195	public boolean isAssignableTo(IType itype) {
182	if(this == itype) return true;	196	if(this == itype) return true;
183	Type tp = (Type) itype;	197	Type tp = (Type) itype;
184	if(element != null && tp.element !=null){	198	Element elt1 = po != null ? po.getTypeElement() : element;
		199	Element elt2 = tp.po != null ? tp.po.getTypeElement() : tp.element;
		200	if(elt1 != null && elt2 !=null){
185	//interbal nb type	201	//interbal nb type
186	String rootName = itype.getName();	202	String rootName = itype.getName();
187	TypeElement tEl = (TypeElement) (element instanceof TypeElement ? element : null);	203	TypeElement tEl = (TypeElement) (elt1 instanceof TypeElement ? elt1 : null);
188	return haveInHierarchy(tEl, rootName);	204	return haveInHierarchy(tEl, rootName);
189	} else if (type !=null && tp.type!=null) {	205	} else if (type !=null && tp.type!=null) {
190	//java type	206	//java type
Lines 196-207 Link Here
196		212
197	@Override	213	@Override
198	public boolean isEnum() {	214	public boolean isEnum() {
199	return (element instanceof TypeElement ? ((TypeElement)element).getKind() == ElementKind.ENUM : (type != null) && type.isEnum());	215	Element elt = po != null ? po.getTypeElement() : element;
		216	return (elt instanceof TypeElement ? ((TypeElement)elt).getKind() == ElementKind.ENUM : (type != null) && type.isEnum());
200	}	217	}
201		218
202	@Override	219	@Override
203	public boolean isResolvable() {	220	public boolean isResolvable() {
204	return type!=null \|\| element!=null;	221	return type!=null \|\| element!=null \|\| po!=null;
205	}	222	}
206		223
207	@Override	224	@Override

Lines 59-64 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/TypeRepository.java (-3 / +6 lines)
59	import org.netbeans.api.project.ProjectUtils;	59	import org.netbeans.api.project.ProjectUtils;
60	import org.netbeans.api.project.SourceGroup;	60	import org.netbeans.api.project.SourceGroup;
61	import org.netbeans.api.project.Sources;	61	import org.netbeans.api.project.Sources;
		62	import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.AnnotationModelHelper;
		63	import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.PersistentObject;
62	import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;	64	import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;
63	import org.netbeans.modules.j2ee.persistence.unit.PUDataObject;	65	import org.netbeans.modules.j2ee.persistence.unit.PUDataObject;
64	import org.netbeans.modules.j2ee.persistence.util.MetadataModelReadHelper;	66	import org.netbeans.modules.j2ee.persistence.util.MetadataModelReadHelper;
Lines 132-139 Link Here
132	int lastPnt = fqn.lastIndexOf('.');	134	int lastPnt = fqn.lastIndexOf('.');
133	ManagedType mt = (ManagedType) (lastPnt > -1 ? mtp.getManagedType(fqn.substring(lastPnt+1)) : mtp.getManagedType(fqn));	135	ManagedType mt = (ManagedType) (lastPnt > -1 ? mtp.getManagedType(fqn.substring(lastPnt+1)) : mtp.getManagedType(fqn));
134	if(mt != null && mt.getPersistentObject() != null && mt.getPersistentObject().getTypeElement()!=null && mt.getPersistentObject().getTypeElement().getQualifiedName().contentEquals(fqn)) {	136	if(mt != null && mt.getPersistentObject() != null && mt.getPersistentObject().getTypeElement()!=null && mt.getPersistentObject().getTypeElement().getQualifiedName().contentEquals(fqn)) {
135	TypeElement te = mt.getPersistentObject().getTypeElement();	137	types.put(fqn, new Type[]{new Type(TypeRepository.this, mt.getPersistentObject())});
136	types.put(fqn, new Type[]{new Type(TypeRepository.this, te)});
137	} else {	138	} else {
138	//	139	//
139	fillTypeElement(fqn);	140	fillTypeElement(fqn);
Lines 157-162 Link Here
157	SourceGroup firstGroup=groups[0];	158	SourceGroup firstGroup=groups[0];
158	FileObject fo=firstGroup.getRootFolder();	159	FileObject fo=firstGroup.getRootFolder();
159	ClasspathInfo classpathInfo = ClasspathInfo.create(fo);	160	ClasspathInfo classpathInfo = ClasspathInfo.create(fo);
		161	final AnnotationModelHelper helper = AnnotationModelHelper.create(classpathInfo);
160	JavaSource javaSource = JavaSource.create(classpathInfo);	162	JavaSource javaSource = JavaSource.create(classpathInfo);
161	try {	163	try {
162	javaSource.runModificationTask(new Task<WorkingCopy>() {	164	javaSource.runModificationTask(new Task<WorkingCopy>() {
Lines 165-171 Link Here
165	if(mtp.isValid()) {//model will be filled with nulls after provider invalidation and with values only if valid provider	167	if(mtp.isValid()) {//model will be filled with nulls after provider invalidation and with values only if valid provider
166	TypeElement te = wc.getElements().getTypeElement(fqn);	168	TypeElement te = wc.getElements().getTypeElement(fqn);
167	if(te!=null) {	169	if(te!=null) {
168	types.put(fqn, new Type[]{new Type(TypeRepository.this, te)});	170	PersistentObject po = new PersistentObject(helper, te) {};
		171	types.put(fqn, new Type[]{new Type(TypeRepository.this, po)});
169	}	172	}
170	}	173	}
171	}	174	}

Lines 95-101 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/ManagedTypeProvider.java (-1 / +1 lines)
95	public IManagedType getManagedType(IType itype) {	95	public IManagedType getManagedType(IType itype) {
96	initializeManagedTypes();	96	initializeManagedTypes();
97	for (IManagedType mt : managedTypes.values()) {	97	for (IManagedType mt : managedTypes.values()) {
98	if (mt.getType().equals(itype)) {	98	if (isValid() && mt.getType().equals(itype)) {
99	return mt;	99	return mt;
100	}	100	}
101	}	101	}




 */
package org.netbeans.modules.j2ee.persistence.spi.jpql;

import java.io.IOException;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.concurrent.Callable;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;

import org.eclipse.persistence.jpa.jpql.spi.IType;
import org.eclipse.persistence.jpa.jpql.spi.ITypeDeclaration;
import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;
import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.AnnotationModelHelper;
import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.PersistentObject;
import org.openide.util.Exceptions;

/**
 *

        this.po = po;
        this.repository = typeRepository;
        type = null;
        typeName = po.getTypeElementHandle().getQualifiedName();
    }
    
    public Type(ITypeRepository typeRepository, Element element){

        if(constructors == null){
            constructors = new ArrayList<IConstructor>();
            if(po!=null) {
                collectConstructors(constructors, getTypeElement(po));
            } else if(element != null){
                collectConstructors(constructors, element);
            } else if (type != null) {

    @Override
    public String[] getEnumConstants() {
        if(enumConstants == null){
            Element elt = po != null ? getTypeElement(po) : element;
            if(elt != null){
                ArrayList<String> constants = new ArrayList<String>();
                for( Element el:elt.getEnclosedElements() ){

    @Override
    public String getName() {
        if(typeName == null){
            Element elt = po != null ? getTypeElement(po) : element;
            if(elt != null){
                if(elt instanceof TypeElement) typeName = ((TypeElement) elt).getQualifiedName().toString();
                else typeName = elt.asType().toString();


    @Override
    public boolean hasAnnotation(Class<? extends Annotation> type) {
        Element elt = po != null ? getTypeElement(po) : element;
        return elt != null ? (elt.getAnnotation(type) != null) : (type!=null && type.isAnnotationPresent(type));
    }


    public boolean isAssignableTo(IType itype) {
        if(this == itype) return true;
        Type tp = (Type) itype;
        Element elt1 = po != null ? getTypeElement(po) : element;
        Element elt2 = tp.po != null ? getTypeElement(tp.po) : tp.element;
        if(elt1 != null && elt2 !=null){
            //interbal nb type
            String rootName = itype.getName();


    @Override
    public boolean isEnum() {
        Element elt = po != null ? getTypeElement(po) : element;
        return  (elt instanceof TypeElement ? ((TypeElement)elt).getKind() == ElementKind.ENUM : (type != null) && type.isEnum());
    }


    ITypeRepository getTypeRepository() {
        return repository;
    }
    
    private TypeElement getTypeElement(final PersistentObject po){
        if(true)return po.getTypeElement();
        TypeElement te = null;
       TypeRepository tr = (TypeRepository) this.repository;
       final AnnotationModelHelper amh = tr.getAnnotationModelHelper();
       if(amh!=null) {
            try {
                te = amh.runJavaSourceTask(new Callable<TypeElement>() {

                @Override
                public TypeElement call() throws Exception {
                    return po.getTypeElement();
                }
            });
            } catch (IOException ex) {
               
            }
       }
       return te;
    }
}




import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import javax.lang.model.element.TypeElement;
import org.eclipse.persistence.jpa.jpql.TypeHelper;
import org.eclipse.persistence.jpa.jpql.spi.IManagedType;
import org.eclipse.persistence.jpa.jpql.spi.IType;
import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.source.ClasspathInfo;
import org.netbeans.api.java.source.JavaSource;
import org.netbeans.api.java.source.Task;
import org.netbeans.api.java.source.WorkingCopy;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;

import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.AnnotationModelHelper;
import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.PersistentObject;
import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;
import org.netbeans.modules.j2ee.persistence.unit.PUDataObject;
import org.netbeans.modules.j2ee.persistence.util.MetadataModelReadHelper;
import org.openide.filesystems.FileObject;
import org.openide.util.Exceptions;

/**
 *

public class TypeRepository implements ITypeRepository {
    private final Project project;
    private final Map<String, IType[]> types;
    private PUDataObject dObj;
    private MetadataModelReadHelper<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>> readHelper;
    private final ManagedTypeProvider mtp;
    private AnnotationModelHelper amh;


    TypeRepository(Project project, ManagedTypeProvider mtp) {

    }
    
    private void fillTypeElement(final String fqn){
        Sources sources=ProjectUtils.getSources(project);
        SourceGroup groups[]=sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
        types.put(fqn, new Type[]{null});
        if(mtp.isValid()){ 
            getAnnotationModelHelper();
            if(amh != null && mtp.isValid()) {
                try {
                    amh.runJavaSourceTask(new Callable<Void>() {

                        @Override
                        public Void call() throws Exception {
                                if(mtp.isValid()) {//model will be filled with nulls  after provider invalidation and with values only if valid provider
                                    TypeElement te = amh.getCompilationController().getElements().getTypeElement(fqn);
                                    if(te!=null) {
                                        PersistentObject po = new PersistentObject(amh, te) {};
                                        types.put(fqn, new Type[]{new Type(TypeRepository.this, po)});
                                    }
                                }
                                return null;
                        }
                    });
                } catch (IOException ex) {
                    //TODO: any logging?
                }
            }
        }
    }

        types.put(type.getName(), new Type[]{new Type(TypeRepository.this, type)});
    }
    
    AnnotationModelHelper getAnnotationModelHelper() {
        if(amh == null) {
                Sources sources=ProjectUtils.getSources(project);
                SourceGroup groups[]=sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
                if(groups != null && groups.length>0){
                    SourceGroup firstGroup=groups[0];
                    FileObject fo=firstGroup.getRootFolder();
                    ClasspathInfo classpathInfo = ClasspathInfo.create(fo);
                    amh = AnnotationModelHelper.create(classpathInfo);
                }            
        }
        return amh;
    }
}

Lines 90-96 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/ManagedType.java (+2 lines)
90	@Override	90	@Override
91	public IType getType() {	91	public IType getType() {
92	if (type == null) {	92	if (type == null) {
		93	if(((ManagedTypeProvider)provider).isValid()){
93	type = provider.getTypeRepository().getType(element.getTypeElement().getQualifiedName().toString());	94	type = provider.getTypeRepository().getType(element.getTypeElement().getQualifiedName().toString());
		95	}
94	}	96	}
95	return type;	97	return type;
96	}	98	}




    }
    
    private TypeElement getTypeElement(final PersistentObject po){
        if(((TypeRepository) repository).isValid()){
            return po.getTypeElement();
        } else {
            return null;
        }
            try {
                te = amh.runJavaSourceTask(new Callable<TypeElement>() {

                @Override
                public TypeElement call() throws Exception {
                    return po.getTypeElement();
                }
            });
            } catch (IOException ex) {
               
            }
       }
       return te;
    }
}




    @Override
    public IType getType(String fqn) {
        IType[] ret = types.get(fqn);
        if(ret == null && isValid()){
            if(IType.UNRESOLVABLE_TYPE.equals(fqn)){
                types.put(fqn, new Type[] {new Type(this, fqn)});
            } else {

    
    private void fillTypeElement(final String fqn){
        types.put(fqn, new Type[]{null});
        if(isValid()){ 
            getAnnotationModelHelper();
            if(amh != null && isValid()) {
                try {
                    amh.runJavaSourceTask(new Callable<Void>() {

                        @Override
                        public Void call() throws Exception {
                                if(isValid()) {//model will be filled with nulls  after provider invalidation and with values only if valid provider
                                    TypeElement te = amh.getCompilationController().getElements().getTypeElement(fqn);
                                    if(te!=null) {
                                        PersistentObject po = new PersistentObject(amh, te) {};

        }
        return amh;
    }
    
    boolean isValid(){
        return mtp.isValid();
    }
}




public class JPQLValidation extends JPAClassRule implements CancelListener{
    
    private ManagedTypeProvider mtp;//need to store as jpql validation may be too long and need to be cancelled if required
    private JPQLQueryHelper helper;
    /** Creates a new instance of NonFinalClass */
    public JPQLValidation() {
        setClassContraints(Arrays.asList(ClassConstraints.ENTITY,

                }
            }
        }
        helper = new JPQLQueryHelper();
        Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
        List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();
        mtp = new ManagedTypeProvider(project, jpaCtx.getMetaData(), jpaCtx.getCompilationInfo().getElements());
        for(int index=0;index<values.size() && !ctx.isCancelled();index++){
            String value = values.get(index);
            String qName = names.get(index);

        }
        jpaCtx.removeCancelListener(this);
        mtp = null;
        helper = null;
        return ret;
    }
    

    @Override
    public void cancelled() {
        if(mtp != null)mtp.invalidate();
        if(helper != null)helper.dispose();
    }
}

Lines 138-144 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/editor/completion/ETCompletionContextResolver.java (-2 / +2 lines)
138	JPQLQueryHelper helper = new JPQLQueryHelper();	138	JPQLQueryHelper helper = new JPQLQueryHelper();
139		139
140	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());	140	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
141	helper.setQuery(new Query(null, completedValue, new ManagedTypeProvider(project, ctx.getEntityMappings())));	141	helper.setQuery(new Query(null, completedValue, new ManagedTypeProvider(project, ctx.getEntityMappings(), ctx.getController().getElements())));
142	int offset = ctx.getCompletionOffset() - nnattr.getValueOffset() - (nnattr.isValueQuoted() ? 1 : 0);	142	int offset = ctx.getCompletionOffset() - nnattr.getValueOffset() - (nnattr.isValueQuoted() ? 1 : 0);
143	ContentAssistProposals buildContentAssistProposals = helper.buildContentAssistProposals(offset);	143	ContentAssistProposals buildContentAssistProposals = helper.buildContentAssistProposals(offset);
144		144
Lines 168-174 Link Here
168	completedValue = org.netbeans.modules.j2ee.persistence.editor.completion.Utils.unquote(completedValue);	168	completedValue = org.netbeans.modules.j2ee.persistence.editor.completion.Utils.unquote(completedValue);
169		169
170	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());	170	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
171	helper.setQuery(new Query(null, completedValue, new ManagedTypeProvider(project, ctx.getEntityMappings())));	171	helper.setQuery(new Query(null, completedValue, new ManagedTypeProvider(project, ctx.getEntityMappings(), ctx.getController().getElements())));
172	int offset = ctx.getCompletionOffset() - method.getValueOffset() - (method.isWithQ() ? 1 : 0);	172	int offset = ctx.getCompletionOffset() - method.getValueOffset() - (method.isWithQ() ? 1 : 0);
173	ContentAssistProposals buildContentAssistProposals = helper.buildContentAssistProposals(offset);	173	ContentAssistProposals buildContentAssistProposals = helper.buildContentAssistProposals(offset);
174		174




import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.lang.model.util.Elements;
import org.eclipse.persistence.jpa.jpql.spi.IEntity;
import org.eclipse.persistence.jpa.jpql.spi.IJPAVersion;
import org.eclipse.persistence.jpa.jpql.spi.IManagedType;

    private ITypeRepository typeRepository;
    private final EntityMappings mappings;
    private boolean valid = true;//used to conrol long tasks, if not valid long tasks should be either terminated or goes short way
    private final Elements elements;

    public ManagedTypeProvider(Project project, EntityMappingsMetadata metaData, Elements elements) {
        this.project = project;
        this.mappings = metaData.getRoot();
        this.elements = elements;
    }
    
    public ManagedTypeProvider(Project project, EntityMappings mappings, Elements elements) {
        this.project = project;
        this.mappings = mappings;
        this.elements = elements;
    }
    
    @Override

    @Override
    public ITypeRepository getTypeRepository() {
        if (typeRepository == null) {
            typeRepository = new TypeRepository(project, this, elements);
        }
        return typeRepository;
    }

    public void invalidate() {
        valid = false;
        //TODO: may have sense to clean stored data
        ((TypeRepository)typeRepository).invalidate();
    }

    private void initializeManagedTypes() {




 */
package org.netbeans.modules.j2ee.persistence.spi.jpql;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.Elements;
import org.eclipse.persistence.jpa.jpql.TypeHelper;
import org.eclipse.persistence.jpa.jpql.spi.IType;
import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.source.ClasspathInfo;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;
import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.AnnotationModelHelper;
import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.PersistentObject;
import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;
import org.netbeans.modules.j2ee.persistence.util.MetadataModelReadHelper;
import org.openide.filesystems.FileObject;

/**
 *

public class TypeRepository implements ITypeRepository {
    private final Project project;
    private final Map<String, IType[]> types;
    private final Map<String, Boolean> packages;
    private MetadataModelReadHelper<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>> readHelper;
    private final ManagedTypeProvider mtp;
    private final Elements elements;


    TypeRepository(Project project, ManagedTypeProvider mtp, Elements elements) {
        this.project = project;
        this.mtp = mtp;
        this.elements = elements;
        types = new HashMap<String, IType[]>();
        packages = new HashMap<String, Boolean>();
    }
    
    @Override

            if(mainPart != null){
                IType[] mainType = types.get(mainPart);
                if(mainType == null){
                    //first check packages
                    int mainFirstPoint = mainPart.indexOf('.');
                    int mainLastPoint = mainPart.lastIndexOf('.');
                    
                    if(mainFirstPoint != mainLastPoint && mainFirstPoint>-1){
                        //we have at least 2 points and at least one for package (we may have nested enums)
                        for(int packagePartIndex = mainFirstPoint;packagePartIndex<mainLastPoint && packagePartIndex>-1;packagePartIndex = mainPart.indexOf('.', packagePartIndex+1)){
                            String packageStr = mainPart.substring(0,packagePartIndex);
                            Boolean exist = packages.get(packageStr);
                            if(exist == null){
                                packages.put(packageStr, elements.getPackageElement(packageStr)!=null);
                                exist = packages.get(packageStr);
                            }
                            if(Boolean.FALSE.equals(exist)){
                                mainType = new Type[]{null};
                                types.put(mainPart, mainType);
                                break;
                            }
                        }
                    }
                    //
                    if(mainType == null){
                        fillTypeElement(mainPart);
                    }
                }
                mainType = types.get(mainPart);
                if(mainType[0] != null){

            }
            ret = types.get(fqn);
        }
        return ret!=null ? ret[0] : null;
    }

    @Override

    private void fillTypeElement(final String fqn){
        types.put(fqn, new Type[]{null});
        if(isValid()){ 
            if(isValid()) {
                TypeElement te = elements.getTypeElement(fqn);
                if(te!=null) {
                    types.put(fqn, new Type[]{new Type(TypeRepository.this, te)});

                        @Override
                        public Void call() throws Exception {
                                if(isValid()) {//model will be filled with nulls  after provider invalidation and with values only if valid provider
                                    TypeElement te = amh.getCompilationController().getElements().getTypeElement(fqn);
                                    if(te!=null) {
                                        PersistentObject po = new PersistentObject(amh, te) {};
                                        types.put(fqn, new Type[]{new Type(TypeRepository.this, po)});
                                    }
                                }
                                return null;
                        }
                    });
                } catch (IOException ex) {
                    //TODO: any logging?
                }
            }
        }

    private void fillTypeElement(Class<?> type){
        types.put(type.getName(), new Type[]{new Type(TypeRepository.this, type)});
    }
   
    AnnotationModelHelper getAnnotationModelHelper() {
        if(amh == null) {
                Sources sources=ProjectUtils.getSources(project);
                SourceGroup groups[]=sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
                if(groups != null && groups.length>0){
                    SourceGroup firstGroup=groups[0];
                    FileObject fo=firstGroup.getRootFolder();
                    ClasspathInfo classpathInfo = ClasspathInfo.create(fo);
                    amh = AnnotationModelHelper.create(classpathInfo);
                }            
        }
        return amh;
    }
    
    boolean isValid(){
        return mtp.isValid();
    }

    void invalidate() {
        
    }
}

Lines 149-155 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/ManagedTypeProvider.java (-1 / +4 lines)
149	public void invalidate() {	149	public void invalidate() {
150	valid = false;	150	valid = false;
151	//TODO: may have sense to clean stored data	151	//TODO: may have sense to clean stored data
152	((TypeRepository)typeRepository).invalidate();	152	if(typeRepository != null) {
		153	((TypeRepository)typeRepository).invalidate();
		154	typeRepository = null;
		155	}
153	}	156	}
154		157
155	private void initializeManagedTypes() {	158	private void initializeManagedTypes() {




 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

package org.netbeans.modules.j2ee.jpa.verification.rules.entity;

import java.util.ArrayList;

import java.util.List;
import java.util.ListResourceBundle;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.logging.Level;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.AnnotationValue;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import org.eclipse.persistence.jpa.internal.jpql.JPQLQueryProblemResourceBundle;
import org.eclipse.persistence.jpa.jpql.JPQLQueryHelper;
import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.modules.j2ee.jpa.model.JPAAnnotations;
import org.netbeans.modules.j2ee.jpa.verification.CancelListener;
import org.netbeans.modules.j2ee.jpa.verification.JPAClassRule;
import org.netbeans.modules.j2ee.jpa.verification.JPAClassRule.ClassConstraints;
import org.netbeans.modules.j2ee.jpa.verification.JPAProblemContext;
import org.netbeans.modules.j2ee.jpa.verification.JPAProblemFinder;
import org.netbeans.modules.j2ee.jpa.verification.common.ProblemContext;
import org.netbeans.modules.j2ee.jpa.verification.common.Utilities;
import org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity;
import org.netbeans.modules.j2ee.persistence.api.metadata.orm.NamedQuery;
import org.netbeans.modules.j2ee.persistence.spi.jpql.ManagedTypeProvider;

import org.netbeans.spi.editor.hints.Severity;

/**
 * Verify content of
 *
 * @NamedQuery query TODO: good to move warning to query level instead of class
 * level
 */
public class JPQLValidation extends JPAClassRule implements CancelListener {

    private ManagedTypeProvider mtp;//need to store as jpql validation may be too long and need to be cancelled if required
    private JPQLQueryHelper helper;

    /**
     * Creates a new instance of NonFinalClass
     */
    public JPQLValidation() {
        setClassContraints(Arrays.asList(ClassConstraints.ENTITY,
                ClassConstraints.EMBEDDABLE,
                ClassConstraints.MAPPED_SUPERCLASS));
    }

    @Override
    public ErrorDescription[] apply(TypeElement subject, ProblemContext ctx) {
        JPAProblemContext jpaCtx = (JPAProblemContext) ctx;
        jpaCtx.addCancelListener(this);
        Object modEl = ctx.getModelElement();
        Entity entity = (Entity) (modEl instanceof Entity ? modEl : null);
        List<AnnotationMirror> first = Utilities.findAnnotations(subject, JPAAnnotations.NAMED_QUERY);
        ArrayList<String> values = new ArrayList<String>();
        ArrayList<String> names = new ArrayList<String>();
        if(first == null || first.size()==0){
            AnnotationMirror qs = Utilities.findAnnotation(subject, JPAAnnotations.NAMED_QUERIES);
            if(qs != null){
                Map<? extends ExecutableElement, ? extends AnnotationValue> maps = qs.getElementValues();
                for(AnnotationValue vl:maps.values()){
                    List  lst = (List) vl.getValue();
                    for(Object val:lst){
                        if(val instanceof AnnotationMirror){
                            AnnotationMirror am = (AnnotationMirror) val;
                            if(JPAAnnotations.NAMED_QUERY.equals(am.getAnnotationType().toString())){
                                AnnotationValue qAttrValue = Utilities.getAnnotationAttrValue(am, "query");
                                AnnotationValue nmAttrValue = Utilities.getAnnotationAttrValue(am, "name");
                                if(qAttrValue != null){
                                    values.add(qAttrValue.getValue().toString());
                                    names.add(nmAttrValue == null ? "" : nmAttrValue.getValue().toString());
                                }
                            }
                        }
                    }
                }
            }
        }
        else {
            for(AnnotationMirror mr:first){
                AnnotationValue qAttrValue = Utilities.getAnnotationAttrValue(mr, "query");
                AnnotationValue nmAttrValue = Utilities.getAnnotationAttrValue(mr, "name");
                if(qAttrValue != null){
                    values.add(qAttrValue.getValue().toString());
                    names.add(nmAttrValue == null ? "" : nmAttrValue.getValue().toString());
                }
            }
        }
        helper = new JPQLQueryHelper();
        Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
        List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();
        mtp = new ManagedTypeProvider(project, jpaCtx.getMetaData(), jpaCtx.getCompilationInfo().getElements());
        if (entity != null) {
            for (NamedQuery nq : entity.getNamedQuery()) {
                helper.setQuery(new Query(nq, nq.getQuery(), mtp));
                List<JPQLQueryProblem> tmp = null;
                try {
                    tmp = helper.validate();
                } catch (UnsupportedOperationException ex) {
                    JPAProblemFinder.LOG.log(Level.INFO, "Unsupported jpql validation case: " + ex.getMessage(), ex);
                } catch (NullPointerException ex) {
                    JPAProblemFinder.LOG.log(Level.INFO, "NPE in jpql validation: " + ex.getMessage(), ex);
                }
                if (tmp != null && tmp.size() > 0) {
                    problems.addAll(tmp);
                }
                helper.dispose();
            }
            helper.setQuery(new Query(nq, value, mtp));
            List<JPQLQueryProblem> tmp = null;
            try{
                tmp = helper.validate();
            } catch (UnsupportedOperationException ex) {
                JPAProblemFinder.LOG.log(Level.INFO, "Unsupported jpql validation case: " + ex.getMessage(), ex);
            }catch (NullPointerException ex) {
                JPAProblemFinder.LOG.log(Level.INFO, "NPE in jpql validation: " + ex.getMessage(), ex);
            }
            if(tmp!=null && tmp.size()>0)problems.addAll(tmp);
            helper.dispose();
        }
        ErrorDescription[] ret = null;
        if (!ctx.isCancelled() && problems != null && problems.size() > 0) {
            ret = new ErrorDescription[problems.size()];
            for (int i = 0; i < ret.length; i++) {
                ListResourceBundle msgBundle = null;
                try {
                    msgBundle = (ListResourceBundle) ResourceBundle.getBundle(JPQLQueryProblemResourceBundle.class.getName());//NOI18N
                } catch (MissingResourceException ex) {//default en
                    msgBundle = (ListResourceBundle) ResourceBundle.getBundle(JPQLQueryProblemResourceBundle.class.getName(), Locale.ENGLISH);//NOI18N
                }
                String message = java.text.MessageFormat.format(msgBundle.getString(problems.get(i).getMessageKey()), (Object[]) problems.get(i).getMessageArguments());
                String pos = "[" + problems.get(i).getStartPosition() + ";" + problems.get(i).getEndPosition() + "]";
                Query q = (Query) problems.get(i).getQuery();
                if (q.getNamedQuery() != null && q.getNamedQuery().getName() != null) {
                    pos = q.getNamedQuery().getName() + pos;
                }
                ret[i] = createProblem(subject, ctx, pos + ": " + message, Severity.WARNING);
            }
        }
        jpaCtx.removeCancelListener(this);

        helper = null;
        return ret;
    }

    @Override
    protected boolean isApplicable(TypeElement subject, ProblemContext ctx) {
        JPAProblemContext jpaCtx = (JPAProblemContext) ctx;

        return (jpaCtx.isEntity() || jpaCtx.isMappedSuperClass());
    }

    @Override
    public void cancelled() {
        if (mtp != null) {
            mtp.invalidate();
        }
        if (helper != null) {
            helper.dispose();
        }
    }
}




        AnnotationMirror entityAnn = annByType.get("javax.persistence.Entity"); // NOI18N
        if (entityAnn == null) {
            return false;
        }
        AnnotationParser parser = AnnotationParser.create(helper);
        parser.expectString("name", AnnotationParser.defaultValue(typeElement.getSimpleName().toString())); // NOI18N
        ParseResult parseResult = parser.parse(entityAnn); // NOI18N

        // XXX locale?
        table = new TableImpl(helper, annByType.get("javax.persistence.Table"), name.toUpperCase()); // NOI18N
        //fill named queries
        AnnotationMirror nqsAnn = annByType.get("javax.persistence.NamedQueries");// NOI18N
        ArrayList<AnnotationMirror> nqAnn = null;
        if(nqsAnn == null){
            nqsAnn = annByType.get("javax.persistence.NamedQuery");// NOI18N
            if(nqsAnn != null){
                nqAnn = new ArrayList<AnnotationMirror>();
                nqAnn.add(nqsAnn);

                    for(Object val:lst){
                        if(val instanceof AnnotationMirror){
                            AnnotationMirror am = (AnnotationMirror) val;
                            if("javax.persistence.NamedQuery".equals(am.getAnnotationType().toString())){//NOI18N
                                nqAnn.add(am);
                                //values.add(Utilities.getAnnotationAttrValue(am, "query").toString());
                            }
                        }
                    }

            for(AnnotationMirror am:nqAnn){
                parseResult = parser.parse(am); // NOI18N
                String nm = parseResult.get("name", String.class); // NOI18N            
                parseResult = parser.parse(am); // NOI18N
                String qr = parseResult.get("query", String.class); // NOI18N
                this.addNamedQuery(new NamedQueryImpl(nm, qr));
            }

Lines 103-108 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/TypeRepository.java (+3 lines)
103	break;	103	break;
104	}	104	}
105	}	105	}
		106	} else if(mainFirstPoint == -1) {
		107	mainType = new Type[]{null};
		108	types.put(mainPart, mainType);
106	}	109	}
107	//	110	//
108	if(mainType == null){	111	if(mainType == null){

Lines 232-237 Link Here

(-)a/html.navigator/src/org/netbeans/modules/html/navigator/HtmlNavigatorPanelUI.java (-9 / +19 lines)
232	//no need to explicitly call pageModelDocumentChanged() as the	232	//no need to explicitly call pageModelDocumentChanged() as the
233	//PageModel fill fire change event	233	//PageModel fill fire change event
234	}	234	}
		235	inspectedFileObject = getInspectedFileFromPageModel();
235		236
236	}	237	}
237		238
Lines 349-354 Link Here
349	}	350	}
350		351
351	private void cacheDomToNb(Node root) {	352	private void cacheDomToNb(Node root) {
		353	if (root==null)
		354	return;
352	if (root instanceof HtmlElementNode) {	355	if (root instanceof HtmlElementNode) {
353	Node res = ((HtmlElementNode) root).getDOMNode();	356	Node res = ((HtmlElementNode) root).getDOMNode();
354	if (res!=null) {	357	if (res!=null) {
Lines 363-371 Link Here
363	private void refreshNodeDOMStatus() {	366	private void refreshNodeDOMStatus() {
364	LOGGER.fine("refreshNodeDOMStatus()");	367	LOGGER.fine("refreshNodeDOMStatus()");
365	HtmlElementNode root = getRootNode();	368	HtmlElementNode root = getRootNode();
		369	boolean refresh = true;
366	if (root != null) {	370	if (root != null) {
367	//if we are inspecting the current file, the source changes propagates just after the fresh DOM is received	371	//if we are inspecting the current file, the source changes propagates just after the fresh DOM is received
368	if(sourceDescription != null) {	372	if(sourceDescription != null) {
		373	refresh = sourceDescription.getFileObject().equals(inspectedFileObject);
369	root.setDescription(sourceDescription);	374	root.setDescription(sourceDescription);
370	sourceDescription = null;	375	sourceDescription = null;
371	setSynchronizationState(true);	376	setSynchronizationState(true);
Lines 382-388 Link Here
382	}	387	}
383	};	388	};
384	domDescription.addChangeListener(WeakListeners.change(changeListener, domDescription));	389	domDescription.addChangeListener(WeakListeners.change(changeListener, domDescription));
385	root.setDescription(domDescription);	390	if (refresh) {
		391	root.setDescription(domDescription);
		392	} else {
		393	root.setDescription(WebKitNodeDescription.empty(WebKitNodeDescription.DOM));
		394	}
386		395
387	LOGGER.fine("root.refreshDOMStatus() called");	396	LOGGER.fine("root.refreshDOMStatus() called");
388	}	397	}
Lines 452-461 Link Here
452		461
453	if (fo==null)	462	if (fo==null)
454	return;	463	return;
455	if (inspectedFileObject == fo) {
456	refreshDOM();
457	return;
458	}
459		464
460	if (!"text/html".equals(FileUtil.getMIMEType(fo))) {	465	if (!"text/html".equals(FileUtil.getMIMEType(fo))) {
461	return;	466	return;
Lines 465-478 Link Here
465	if (source == null) {	470	if (source == null) {
466	return;	471	return;
467	}	472	}
468	showWaitNode();	473
		474	//TODO: uncomment when working again
		475	//showWaitNode();
469		476
470	try {	477	try {
471	ParserManager.parse(Collections.singleton(source), new UserTask() {	478	ParserManager.parse(Collections.singleton(source), new UserTask() {
472	@Override	479	@Override
473	public void run(ResultIterator resultIterator) throws Exception {	480	public void run(ResultIterator resultIterator) throws Exception {
474	setParserResult((HtmlParserResult)resultIterator.getParserResult());	481	setParserResult((HtmlParserResult)resultIterator.getParserResult());
475	inspectedFileObject = fo;	482	//inspectedFileObject = getInspectedFileFromPageModel();
476	refreshDOM();	483	refreshDOM();
477	}	484	}
478	});	485	});
Lines 793-802 Link Here
793	if (node instanceof HtmlElementNode) {	800	if (node instanceof HtmlElementNode) {
794	final Node domNode = ((HtmlElementNode) node).getDOMNode();	801	final Node domNode = ((HtmlElementNode) node).getDOMNode();
795	if (domNode!=null) {	802	if (domNode!=null) {
796	node = domNode;	803	highlight = Arrays.asList(domNode);
		804	} else {
		805	highlight = Collections.EMPTY_LIST;
797	}	806	}
		807	} else {
		808	highlight = Arrays.asList(node);
798	}	809	}
799	highlight = Arrays.asList(node);
800	} else {	810	} else {
801	highlight = Collections.EMPTY_LIST;	811	highlight = Collections.EMPTY_LIST;
802	}	812	}

Return to bug 216053

Lines 291-313 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/Type.java (-18 / +5 lines)
291	}	291	}
292		292
293	private TypeElement getTypeElement(final PersistentObject po){	293	private TypeElement getTypeElement(final PersistentObject po){
294	if(true)return po.getTypeElement();	294	if(((TypeRepository) repository).isValid()){
295	TypeElement te = null;	295	return po.getTypeElement();
296	TypeRepository tr = (TypeRepository) this.repository;	296	} else {
297	final AnnotationModelHelper amh = tr.getAnnotationModelHelper();	297	return null;
298	if(amh!=null) {	298	}
299	try {
300	te = amh.runJavaSourceTask(new Callable<TypeElement>() {
301
302	@Override
303	public TypeElement call() throws Exception {
304	return po.getTypeElement();
305	}
306	});
307	} catch (IOException ex) {
308
309	}
310	}
311	return te;
312	}	299	}
313	}	300	}

Lines 70-117 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/TypeRepository.java (-11 / +16 lines)
70	*/	70	*/
71	public class TypeRepository implements ITypeRepository {	71	public class TypeRepository implements ITypeRepository {
72	private final Project project;	72	private final Project project;
73	private final Map<String, IType> types;	73	private final Map<String, IType[]> types;
74	private PUDataObject dObj;	74	private PUDataObject dObj;
75	private MetadataModelReadHelper<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>> readHelper;	75	private MetadataModelReadHelper<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>> readHelper;
76		76
77	TypeRepository(Project project){	77	TypeRepository(Project project){
78	this.project = project;	78	this.project = project;
79	types = new HashMap<String, IType>();	79	types = new HashMap<String, IType[]>();
80	}	80	}
81		81
82	@Override	82	@Override
83	public IType getEnumType(String fqn) {	83	public IType getEnumType(String fqn) {
84	IType ret = types.get(fqn);	84	System.out.println("ENUM: "+fqn);
		85	IType[] ret = types.get(fqn);
85	if(ret == null){	86	if(ret == null){
86	fillTypeElement(fqn);	87	fillTypeElement(fqn);
87	ret = types.get(fqn);	88	ret = types.get(fqn);
88	}	89	}
89	return ret;	90	return ret[0];
90	}	91	}
91		92
92	@Override	93	@Override
93	public IType getType(Class<?> type) {	94	public IType getType(Class<?> type) {
94	String fqn = type.getCanonicalName();	95	String fqn = type.getCanonicalName();
95	IType ret = types.get(fqn);	96	System.out.println("TYPECL: "+fqn);
		97	IType[] ret = types.get(fqn);
96	if(ret == null){	98	if(ret == null){
97	fillTypeElement(type);	99	fillTypeElement(type);
98	ret = types.get(fqn);	100	ret = types.get(fqn);
99	}	101	}
100	return ret;	102	return ret[0];
101	}	103	}
102		104
103	@Override	105	@Override
104	public IType getType(String fqn) {	106	public IType getType(String fqn) {
105	IType ret = types.get(fqn);	107	System.out.println("TYPEFQ: "+fqn);
		108	IType[] ret = types.get(fqn);
106	if(ret == null){	109	if(ret == null){
107	if(IType.UNRESOLVABLE_TYPE.equals(fqn)){	110	if(IType.UNRESOLVABLE_TYPE.equals(fqn)){
108	types.put(fqn, new Type(this, fqn));	111	types.put(fqn, new Type[] {new Type(this, fqn)});
109	} else {	112	} else {
110	fillTypeElement(fqn);	113	fillTypeElement(fqn);
111	}	114	}
112	ret = types.get(fqn);	115	ret = types.get(fqn);
113	}	116	}
114	return ret;	117	return ret[0];
115	}	118	}
116		119
117	@Override	120	@Override
Lines 120-127 Link Here
120	}	123	}
121		124
122	private void fillTypeElement(final String fqn){	125	private void fillTypeElement(final String fqn){
		126	System.out.println("FILL FQN: "+fqn);
123	Sources sources=ProjectUtils.getSources(project);	127	Sources sources=ProjectUtils.getSources(project);
124	SourceGroup groups[]=sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);	128	SourceGroup groups[]=sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
		129	types.put(fqn, new Type[]{null});
125	if(groups != null && groups.length>0){	130	if(groups != null && groups.length>0){
126	SourceGroup firstGroup=groups[0];	131	SourceGroup firstGroup=groups[0];
127	FileObject fo=firstGroup.getRootFolder();	132	FileObject fo=firstGroup.getRootFolder();
Lines 132-138 Link Here
132	@Override	137	@Override
133	public void run(WorkingCopy wc) throws Exception {	138	public void run(WorkingCopy wc) throws Exception {
134	TypeElement te = wc.getElements().getTypeElement(fqn);	139	TypeElement te = wc.getElements().getTypeElement(fqn);
135	if(te != null)types.put(fqn, new Type(TypeRepository.this, te));	140	if(te!=null) types.put(fqn, new Type[]{new Type(TypeRepository.this, te)});
136	}	141	}
137	});	142	});
138	} catch (IOException ex) {	143	} catch (IOException ex) {
Lines 141-147 Link Here
141	}	146	}
142	}	147	}
143	private void fillTypeElement(Class<?> type){	148	private void fillTypeElement(Class<?> type){
144	types.put(type.getName(), new Type(TypeRepository.this, type));	149	types.put(type.getName(), new Type[]{new Type(TypeRepository.this, type)});
145	}	150	}
146		151
147	}	152	}

Lines 60-66 Link Here

(-)a/j2ee.jpa.verification/src/org/netbeans/modules/j2ee/jpa/verification/rules/entity/JPQLValidation.java (-6 / +3 lines)
60	import org.eclipse.persistence.jpa.internal.jpql.JPQLQueryProblemResourceBundle;	60	import org.eclipse.persistence.jpa.internal.jpql.JPQLQueryProblemResourceBundle;
61	import org.eclipse.persistence.jpa.jpql.JPQLQueryHelper;	61	import org.eclipse.persistence.jpa.jpql.JPQLQueryHelper;
62	import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem;	62	import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem;
63	import org.eclipse.persistence.jpa.jpql.spi.IQuery;
64	import org.netbeans.api.project.FileOwnerQuery;	63	import org.netbeans.api.project.FileOwnerQuery;
65	import org.netbeans.api.project.Project;	64	import org.netbeans.api.project.Project;
66	import org.netbeans.modules.j2ee.jpa.model.JPAAnnotations;	65	import org.netbeans.modules.j2ee.jpa.model.JPAAnnotations;
Lines 81-87 Link Here
81	* Verify content of @NamedQuery query	80	* Verify content of @NamedQuery query
82	* TODO: good to move warning to query level instead of class level	81	* TODO: good to move warning to query level instead of class level
83	*/	82	*/
84	public class JPQLValidation extends JPAClassRule {	83	public class JPQLValidation extends JPAClassRule{
85		84
86	/** Creates a new instance of NonFinalClass */	85	/** Creates a new instance of NonFinalClass */
87	public JPQLValidation() {	86	public JPQLValidation() {
Lines 91-97 Link Here
91	}	90	}
92		91
93	@Override public ErrorDescription[] apply(TypeElement subject, ProblemContext ctx){	92	@Override public ErrorDescription[] apply(TypeElement subject, ProblemContext ctx){
94	long start = System.nanoTime();
95	Object modEl = ctx.getModelElement();	93	Object modEl = ctx.getModelElement();
96	Entity entity = (Entity) (modEl instanceof Entity ? modEl : null);	94	Entity entity = (Entity) (modEl instanceof Entity ? modEl : null);
97	List<AnnotationMirror> first = Utilities.findAnnotations(subject, JPAAnnotations.NAMED_QUERY);	95	List<AnnotationMirror> first = Utilities.findAnnotations(subject, JPAAnnotations.NAMED_QUERY);
Lines 133-139 Link Here
133	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());	131	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
134	List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();	132	List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();
135	ManagedTypeProvider mtp = new ManagedTypeProvider(project, ((JPAProblemContext)ctx).getMetaData());	133	ManagedTypeProvider mtp = new ManagedTypeProvider(project, ((JPAProblemContext)ctx).getMetaData());
136	for(int index=0;index<values.size();index++){	134	for(int index=0;index<values.size() && !ctx.isCancelled();index++){
137	String value = values.get(index);	135	String value = values.get(index);
138	String qName = names.get(index);	136	String qName = names.get(index);
139	NamedQuery nq = null;	137	NamedQuery nq = null;
Lines 153-161 Link Here
153	}	151	}
154	if(tmp!=null && tmp.size()>0)problems.addAll(tmp);	152	if(tmp!=null && tmp.size()>0)problems.addAll(tmp);
155	helper.dispose();	153	helper.dispose();
156	//System.out.println("TIME TO COMPLETE: "+(System.nanoTime() - start));
157	}	154	}
158	if (problems != null && problems.size()>0){	155	if (!ctx.isCancelled() && problems != null && problems.size()>0){
159	ErrorDescription[] ret = new ErrorDescription[problems.size()];	156	ErrorDescription[] ret = new ErrorDescription[problems.size()];
160	for(int i=0;i<ret.length;i++){	157	for(int i=0;i<ret.length;i++){
161	ListResourceBundle msgBundle = null;	158	ListResourceBundle msgBundle = null;

Line 0 Link Here

(-)a/j2ee.jpa.verification/src/org/netbeans/modules/j2ee/jpa/verification/CancelListener.java (+50 lines)
	1	/*
	2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
	3	*
	4	* Copyright 2012 Oracle and/or its affiliates. All rights reserved.
	5	*
	6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
	7	* Other names may be trademarks of their respective owners.
	8	*
	9	* The contents of this file are subject to the terms of either the GNU
	10	* General Public License Version 2 only ("GPL") or the Common
	11	* Development and Distribution License("CDDL") (collectively, the
	12	* "License"). You may not use this file except in compliance with the
	13	* License. You can obtain a copy of the License at
	14	* http://www.netbeans.org/cddl-gplv2.html
	15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
	16	* specific language governing permissions and limitations under the
	17	* License. When distributing the software, include this License Header
	18	* Notice in each file and include the License file at
	19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
	20	* particular file as subject to the "Classpath" exception as provided
	21	* by Oracle in the GPL Version 2 section of the License file that
	22	* accompanied this code. If applicable, add the following below the
	23	* License Header, with the fields enclosed by brackets [] replaced by
	24	* your own identifying information:
	25	* "Portions Copyrighted [year] [name of copyright owner]"
	26	*
	27	* If you wish your version of this file to be governed by only the CDDL
	28	* or only the GPL Version 2, indicate your decision by adding
	29	* "[Contributor] elects to include this software in this distribution
	30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
	31	* single choice of license, a recipient has the option to distribute
	32	* your version of this file under either the CDDL, the GPL Version 2 or
	33	* to extend the choice of license to its licensees as provided above.
	34	* However, if you add GPL Version 2 code and therefore, elected the GPL
	35	* Version 2 license, then the option applies only if the new code is
	36	* made subject to such option by the copyright holder.
	37	*
	38	* Contributor(s):
	39	*
	40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
	41	*/
	42	package org.netbeans.modules.j2ee.jpa.verification;
	43
	44	/**
	45	* handle verification cancelling with this interface
	46	* @author sp153251
	47	*/
	48	public interface CancelListener {
	49	void cancelled();
	50	}

Lines 41-53 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/ManagedTypeProvider.java (-10 / +15 lines)
41	*/	41	*/
42	package org.netbeans.modules.j2ee.persistence.spi.jpql;	42	package org.netbeans.modules.j2ee.persistence.spi.jpql;
43		43
44	import java.util.Arrays;
45	import java.util.Collection;	44	import java.util.Collection;
46	import java.util.Collections;	45	import java.util.Collections;
47	import java.util.HashMap;	46	import java.util.HashMap;
48	import java.util.List;
49	import java.util.Map;	47	import java.util.Map;
50	import java.util.concurrent.ExecutionException;
51	import org.eclipse.persistence.jpa.jpql.spi.IEntity;	48	import org.eclipse.persistence.jpa.jpql.spi.IEntity;
52	import org.eclipse.persistence.jpa.jpql.spi.IJPAVersion;	49	import org.eclipse.persistence.jpa.jpql.spi.IJPAVersion;
53	import org.eclipse.persistence.jpa.jpql.spi.IManagedType;	50	import org.eclipse.persistence.jpa.jpql.spi.IManagedType;
Lines 56-70 Link Here
56	import org.eclipse.persistence.jpa.jpql.spi.IType;	53	import org.eclipse.persistence.jpa.jpql.spi.IType;
57	import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;	54	import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;
58	import org.netbeans.api.project.Project;	55	import org.netbeans.api.project.Project;
59	import org.netbeans.modules.j2ee.metadata.model.api.MetadataModel;
60	import org.netbeans.modules.j2ee.metadata.model.api.MetadataModelAction;
61	import org.netbeans.modules.j2ee.persistence.api.EntityClassScope;
62	import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappings;	56	import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappings;
63	import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;	57	import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;
64	import org.netbeans.modules.j2ee.persistence.dd.PersistenceUtils;	58	import org.netbeans.modules.j2ee.persistence.dd.PersistenceUtils;
65	import org.netbeans.modules.j2ee.persistence.util.MetadataModelReadHelper;
66	import org.netbeans.modules.j2ee.persistence.wizard.EntityClosure;
67	import org.openide.util.Exceptions;
68		59
69	/**	60	/**
70	*	61	*
Lines 76-81 Link Here
76	private Map<String, IManagedType> managedTypes;	67	private Map<String, IManagedType> managedTypes;
77	private ITypeRepository typeRepository;	68	private ITypeRepository typeRepository;
78	private final EntityMappings mappings;	69	private final EntityMappings mappings;
		70	private boolean valid = true;//used to conrol long tasks, if not valid long tasks should be either terminated or goes short way
79		71
80	public ManagedTypeProvider(Project project, EntityMappingsMetadata metaData) {	72	public ManagedTypeProvider(Project project, EntityMappingsMetadata metaData) {
81	this.project = project;	73	this.project = project;
Lines 124-130 Link Here
124	@Override	116	@Override
125	public ITypeRepository getTypeRepository() {	117	public ITypeRepository getTypeRepository() {
126	if (typeRepository == null) {	118	if (typeRepository == null) {
127	typeRepository = new TypeRepository(project);	119	typeRepository = new TypeRepository(project, this);
128	}	120	}
129	return typeRepository;	121	return typeRepository;
130	}	122	}
Lines 141-146 Link Here
141	initializeManagedTypes();	133	initializeManagedTypes();
142	return Collections.unmodifiableCollection(managedTypes.values());	134	return Collections.unmodifiableCollection(managedTypes.values());
143	}	135	}
		136
		137	public boolean isValid() {
		138	return valid;
		139	}
		140
		141	/**
		142	* make model invalid and it shoul case processing to stop, minimize etc.
		143	* results with SPI may not be consider valid if provider isn't valid
		144	*/
		145	public void invalidate() {
		146	valid = false;
		147	//TODO: may have sense to clean stored data
		148	}
144		149
145	private void initializeManagedTypes() {	150	private void initializeManagedTypes() {
146	if (managedTypes == null) {	151	if (managedTypes == null) {

Lines 90-96 Link Here

(-)a/j2ee.persistenceapi/src/org/netbeans/modules/j2ee/persistenceapi/metadata/orm/annotation/EntityImpl.java (-6 / +4 lines)
90	AnnotationMirror entityAnn = annByType.get("javax.persistence.Entity"); // NOI18N	90	AnnotationMirror entityAnn = annByType.get("javax.persistence.Entity"); // NOI18N
91	if (entityAnn == null) {	91	if (entityAnn == null) {
92	return false;	92	return false;
93	}annByType.get("javax.persistence.NamedQueries");	93	}
94	AnnotationParser parser = AnnotationParser.create(helper);	94	AnnotationParser parser = AnnotationParser.create(helper);
95	parser.expectString("name", AnnotationParser.defaultValue(typeElement.getSimpleName().toString())); // NOI18N	95	parser.expectString("name", AnnotationParser.defaultValue(typeElement.getSimpleName().toString())); // NOI18N
96	ParseResult parseResult = parser.parse(entityAnn); // NOI18N	96	ParseResult parseResult = parser.parse(entityAnn); // NOI18N
Lines 101-110 Link Here
101	// XXX locale?	101	// XXX locale?
102	table = new TableImpl(helper, annByType.get("javax.persistence.Table"), name.toUpperCase()); // NOI18N	102	table = new TableImpl(helper, annByType.get("javax.persistence.Table"), name.toUpperCase()); // NOI18N
103	//fill named queries	103	//fill named queries
104	AnnotationMirror nqsAnn = annByType.get("javax.persistence.NamedQueries");	104	AnnotationMirror nqsAnn = annByType.get("javax.persistence.NamedQueries");// NOI18N
105	ArrayList<AnnotationMirror> nqAnn = null;	105	ArrayList<AnnotationMirror> nqAnn = null;
106	if(nqsAnn == null){	106	if(nqsAnn == null){
107	nqsAnn = annByType.get("javax.persistence.NamedQuery");	107	nqsAnn = annByType.get("javax.persistence.NamedQuery");// NOI18N
108	if(nqsAnn != null){	108	if(nqsAnn != null){
109	nqAnn = new ArrayList<AnnotationMirror>();	109	nqAnn = new ArrayList<AnnotationMirror>();
110	nqAnn.add(nqsAnn);	110	nqAnn.add(nqsAnn);
Lines 117-125 Link Here
117	for(Object val:lst){	117	for(Object val:lst){
118	if(val instanceof AnnotationMirror){	118	if(val instanceof AnnotationMirror){
119	AnnotationMirror am = (AnnotationMirror) val;	119	AnnotationMirror am = (AnnotationMirror) val;
120	if("javax.persistence.NamedQuery".equals(am.getAnnotationType().toString())){	120	if("javax.persistence.NamedQuery".equals(am.getAnnotationType().toString())){//NOI18N
121	nqAnn.add(am);	121	nqAnn.add(am);
122	//values.add(Utilities.getAnnotationAttrValue(am, "query").toString());
123	}	122	}
124	}	123	}
125	}	124	}
Lines 133-139 Link Here
133	for(AnnotationMirror am:nqAnn){	132	for(AnnotationMirror am:nqAnn){
134	parseResult = parser.parse(am); // NOI18N	133	parseResult = parser.parse(am); // NOI18N
135	String nm = parseResult.get("name", String.class); // NOI18N	134	String nm = parseResult.get("name", String.class); // NOI18N
136	parseResult = parser.parse(am); // NOI18N
137	String qr = parseResult.get("query", String.class); // NOI18N	135	String qr = parseResult.get("query", String.class); // NOI18N
138	this.addNamedQuery(new NamedQueryImpl(nm, qr));	136	this.addNamedQuery(new NamedQueryImpl(nm, qr));
139	}	137	}