private void collectSelects(
QueryBuilderScopeContext qb, MethodReference methodReference, String name) {
if (!Arrays.asList("select", "addSelect").contains(name)) {
return;
}
// $qb->select('foo')
PsiElement psiElement = PsiElementUtils.getMethodParameterPsiElementAt(methodReference, 0);
String literalValue = PhpElementsUtil.getStringValue(psiElement);
if (literalValue != null) {
qb.addSelect(literalValue);
return;
}
// $qb->select(array('foo', 'bar', 'accessoryDetail'))
if (psiElement instanceof ArrayCreationExpression) {
for (PsiElement arrayValue :
PsiElementUtils.getChildrenOfTypeAsList(
psiElement, PlatformPatterns.psiElement(PhpElementTypes.ARRAY_VALUE))) {
if (arrayValue.getChildren().length == 1) {
String arrayValueString = PhpElementsUtil.getStringValue(arrayValue.getChildren()[0]);
if (arrayValueString != null) {
qb.addSelect(arrayValueString);
}
}
}
}
}
protected Collection<PsiElement> classGoToDeclaration(PsiElement psiElement, String className) {
Collection<PsiElement> psiElements = new HashSet<PsiElement>();
// Class::method
// Class::FooAction
// Class:Foo
if (className.contains(":")) {
String[] split = className.replaceAll("(:)\\1", "$1").split(":");
if (split.length == 2) {
for (String append : new String[] {"", "Action"}) {
Method classMethod =
PhpElementsUtil.getClassMethod(psiElement.getProject(), split[0], split[1] + append);
if (classMethod != null) {
psiElements.add(classMethod);
}
}
}
return psiElements;
}
// ClassName
psiElements.addAll(PhpElementsUtil.getClassesInterface(psiElement.getProject(), className));
return psiElements;
}
public static PsiElement findArrayKeyValueInsideReference(
PsiElement psiElement, String methodReferenceName, String keyName) {
if (psiElement == null) {
return null;
}
Collection<MethodReference> tests =
PsiTreeUtil.findChildrenOfType(psiElement, MethodReference.class);
for (MethodReference methodReference : tests) {
// instance check
// methodReference.getSignature().equals("#M#C\\Symfony\\Component\\OptionsResolver\\OptionsResolverInterface.setDefaults")
if (PhpElementsUtil.isEqualMethodReferenceName(methodReference, methodReferenceName)) {
PsiElement[] parameters = methodReference.getParameters();
if (parameters.length > 0 && parameters[0] instanceof ArrayCreationExpression) {
PsiElement keyValue =
PhpElementsUtil.getArrayValue((ArrayCreationExpression) parameters[0], keyName);
if (keyValue != null) {
return keyValue;
}
}
}
}
return null;
}
@NotNull
public static Collection<SymfonyCommand> getCommands(@NotNull Project project) {
Collection<SymfonyCommand> symfonyCommands = new ArrayList<SymfonyCommand>();
for (PhpClass phpClass :
PhpIndex.getInstance(project)
.getAllSubclasses("\\Symfony\\Component\\Console\\Command\\Command")) {
if (PhpElementsUtil.isTestClass(phpClass)) {
continue;
}
Method method = phpClass.findOwnMethodByName("configure");
if (method == null) {
continue;
}
PsiElement[] psiElements =
PsiTreeUtil.collectElements(
method,
new PsiElementFilter() {
@Override
public boolean isAccepted(PsiElement psiElement) {
return psiElement instanceof MethodReference
&& "setName".equals(((MethodReference) psiElement).getName());
}
});
for (PsiElement psiElement : psiElements) {
if (!(psiElement instanceof MethodReference)) {
continue;
}
PsiElement psiMethodParameter =
PsiElementUtils.getMethodParameterPsiElementAt((MethodReference) psiElement, 0);
if (psiMethodParameter == null) {
continue;
}
String stringValue = PhpElementsUtil.getStringValue(psiMethodParameter);
if (stringValue == null) {
continue;
}
symfonyCommands.add(new SymfonyCommand(stringValue, psiElement));
}
}
return symfonyCommands;
}
/** finishView, buildView: $this->vars */
public static Set<String> getFormViewVars(Project project, String... formTypeNames) {
Set<String> stringSet = new HashSet<String>();
ArrayList<PhpClass> phpClasses = new ArrayList<PhpClass>();
// attach core form phpclass
// @TODO: add formtype itself
PhpClass coreForm = FormUtil.getFormTypeToClass(project, "form");
if (coreForm != null) {
phpClasses.add(coreForm);
}
// for extension can also provide vars
for (Map.Entry<String, String> entry :
FormOptionsUtil.getFormExtensionKeys(project, formTypeNames).entrySet()) {
PhpClass phpClass = PhpElementsUtil.getClassInterface(project, entry.getValue());
if (phpClass != null) {
phpClasses.add(phpClass);
}
}
for (PhpClass phpClass : phpClasses) {
for (String stringMethod : new String[] {"finishView", "buildView"}) {
Method method = PhpElementsUtil.getClassMethod(phpClass, stringMethod);
if (method != null) {
// self method
getMethodVars(stringSet, method);
// allow parent::
// @TODO: provide global util method
for (ClassReference classReference :
PsiTreeUtil.collectElementsOfType(method, ClassReference.class)) {
if ("parent".equals(classReference.getName())) {
PsiElement methodReference = classReference.getContext();
if (methodReference instanceof MethodReference) {
PsiElement parentMethod = ((MethodReference) methodReference).resolve();
if (parentMethod instanceof Method) {
getMethodVars(stringSet, (Method) parentMethod);
}
}
}
}
}
}
}
return stringSet;
}
private void buildPropertyMap(QueryBuilderScopeContext qb) {
if (!collectProperties) {
return;
}
for (QueryBuilderJoin join : qb.getJoinMap().values()) {
String className = join.getResolvedClass();
if (className != null) {
PhpClass phpClass = PhpElementsUtil.getClassInterface(project, className);
if (phpClass != null) {
qb.addPropertyAlias(
join.getAlias(),
new QueryBuilderPropertyAlias(
join.getAlias(),
null,
new DoctrineModelField(join.getAlias())
.addTarget(phpClass)
.setTypeName(phpClass.getPresentableFQN())));
// add entity properties
for (DoctrineModelField field : EntityHelper.getModelFields(phpClass)) {
qb.addPropertyAlias(
join.getAlias() + "." + field.getName(),
new QueryBuilderPropertyAlias(join.getAlias(), field.getName(), field));
}
}
}
}
}
@Nullable
@Override
public String getType(PsiElement e) {
if (DumbService.getInstance(e.getProject()).isDumb()
|| !Settings.getInstance(e.getProject()).pluginEnabled
|| !Settings.getInstance(e.getProject()).objectManagerFindTypeProvider) {
return null;
}
if (!(e instanceof MethodReference)
|| !PhpElementsUtil.isMethodWithFirstStringOrFieldReference(e, "find")) {
return null;
}
String refSignature = ((MethodReference) e).getSignature();
if (StringUtil.isEmpty(refSignature)) {
return null;
}
// we need the param key on getBySignature(), since we are already in the resolved method there
// attach it to signature
// param can have dotted values split with \
PsiElement[] parameters = ((MethodReference) e).getParameters();
if (parameters.length == 2) {
return PhpTypeProviderUtil.getReferenceSignature((MethodReference) e, TRIM_KEY, 2);
}
return null;
}
public static ArrayList<String> getExtendedTypeClasses(Project project, String... formTypeNames) {
List<String> formTypeNamesList = Arrays.asList(formTypeNames);
ArrayList<String> extendedTypeClasses = new ArrayList<String>();
FormExtensionServiceParser formExtensionServiceParser =
ServiceXmlParserFactory.getInstance(project, FormExtensionServiceParser.class);
for (String formClass : formExtensionServiceParser.getFormExtensions().keySet()) {
PsiElement psiElements[] =
PhpElementsUtil.getPsiElementsBySignature(
project, "#M#C\\" + formClass + ".getExtendedType");
for (PsiElement psiElement : psiElements) {
PhpReturn phpReturn = PsiTreeUtil.findChildOfType(psiElement, PhpReturn.class);
if (phpReturn != null) {
PhpPsiElement returnValue = phpReturn.getFirstPsiChild();
if (returnValue instanceof StringLiteralExpression
&& formTypeNamesList.contains(
((StringLiteralExpression) returnValue).getContents())) {
extendedTypeClasses.add(formClass);
}
}
}
}
return extendedTypeClasses;
}
/** $this->vars['test'] $view->vars = array_replace($view->vars, array(...)); */
private static void getFormViewVarsAttachKeys(
Set<String> stringSet, FieldReference fieldReference) {
// $this->vars['test']
PsiElement context = fieldReference.getContext();
if (context instanceof ArrayAccessExpression) {
ArrayIndex arrayIndex = PsiTreeUtil.findChildOfType(context, ArrayIndex.class);
if (arrayIndex != null) {
PsiElement psiElement = arrayIndex.getFirstChild();
if (psiElement instanceof StringLiteralExpression) {
String contents = ((StringLiteralExpression) psiElement).getContents();
if (StringUtils.isNotBlank(contents)) {
stringSet.add(contents);
}
}
}
}
// array_replace($view->vars, array(...))
if (context instanceof ParameterList) {
PsiElement functionReference = context.getContext();
if (functionReference instanceof FunctionReference
&& "array_replace".equals(((FunctionReference) functionReference).getName())) {
PsiElement[] psiElements = ((ParameterList) context).getParameters();
if (psiElements.length > 1) {
if (psiElements[1] instanceof ArrayCreationExpression) {
stringSet.addAll(
PhpElementsUtil.getArrayCreationKeys((ArrayCreationExpression) psiElements[1]));
}
}
}
}
}
@Override
protected void addCompletions(
@NotNull CompletionParameters completionParameters,
ProcessingContext processingContext,
@NotNull CompletionResultSet completionResultSet) {
PsiElement position = completionParameters.getPosition();
if (!Symfony2ProjectComponent.isEnabled(position)) {
return;
}
YAMLCompoundValue yamlCompoundValue =
PsiTreeUtil.getParentOfType(position, YAMLCompoundValue.class);
if (yamlCompoundValue == null) {
return;
}
String className =
YamlHelper.getYamlKeyValueAsString(yamlCompoundValue, "targetEntity", false);
if (className == null) {
return;
}
PhpClass phpClass = PhpElementsUtil.getClass(position.getProject(), className);
if (phpClass == null) {
return;
}
for (DoctrineModelField field : EntityHelper.getModelFields(phpClass)) {
if (field.getRelation() != null) {
completionResultSet.addElement(new DoctrineModelFieldLookupElement(field));
}
}
}
public static Collection<PhpClass> getClassFromPhpTypeSetArrayClean(
Project project, Set<String> types) {
PhpType phpType = new PhpType();
phpType.add(types);
ArrayList<PhpClass> phpClasses = new ArrayList<PhpClass>();
for (String typeName :
PhpIndex.getInstance(project)
.completeType(project, phpType, new HashSet<String>())
.getTypes()) {
if (typeName.startsWith("\\")) {
// we clean array types \Foo[]
if (typeName.endsWith("[]")) {
typeName = typeName.substring(0, typeName.length() - 2);
}
PhpClass phpClass = PhpElementsUtil.getClassInterface(project, typeName);
if (phpClass != null) {
phpClasses.add(phpClass);
}
}
}
return phpClasses;
}
@Nullable
public static PsiElement getArrayKeyValueInsideSignaturePsi(
PsiElement psiElementInsideClass, String callTo[], String methodName, String keyName) {
PhpClass phpClass = PsiTreeUtil.getParentOfType(psiElementInsideClass, PhpClass.class);
if (phpClass == null) {
return null;
}
String className = phpClass.getPresentableFQN();
if (className == null) {
return null;
}
for (String s : callTo) {
// @TODO: replace signature
PsiElement arrayKeyValueInsideSignature =
PhpElementsUtil.getArrayKeyValueInsideSignaturePsi(
psiElementInsideClass.getProject(),
"#M#C\\" + className + "." + s,
methodName,
keyName);
if (arrayKeyValueInsideSignature != null) {
return arrayKeyValueInsideSignature;
}
}
return null;
}
/**
* Get array string values mapped with their PsiElements
*
* <p>["value", "value2"]
*/
@NotNull
public static Map<String, PsiElement> getArrayValuesAsMap(
@NotNull ArrayCreationExpression arrayCreationExpression) {
List<PsiElement> arrayValues =
PhpPsiUtil.getChildren(
arrayCreationExpression,
new Condition<PsiElement>() {
@Override
public boolean value(PsiElement psiElement) {
return psiElement.getNode().getElementType() == PhpElementTypes.ARRAY_VALUE;
}
});
if (arrayValues == null) {
return Collections.emptyMap();
}
Map<String, PsiElement> keys = new HashMap<String, PsiElement>();
for (PsiElement child : arrayValues) {
String stringValue = PhpElementsUtil.getStringValue(child.getFirstChild());
if (stringValue != null && StringUtils.isNotBlank(stringValue)) {
keys.put(stringValue, child);
}
}
return keys;
}
@Nullable
public static Method findTwigFileController(TwigFile twigFile) {
SymfonyBundle symfonyBundle =
new SymfonyBundleUtil(twigFile.getProject()).getContainingBundle(twigFile);
if (symfonyBundle == null) {
return null;
}
String relativePath = symfonyBundle.getRelativePath(twigFile.getVirtualFile());
if (relativePath == null || !relativePath.startsWith("Resources/views/")) {
return null;
}
String viewPath = relativePath.substring("Resources/views/".length());
Matcher simpleFilter = Pattern.compile(".*/(\\w+)\\.\\w+\\.twig").matcher(viewPath);
if (!simpleFilter.find()) {
return null;
}
String methodName = simpleFilter.group(1) + "Action";
String className =
symfonyBundle.getNamespaceName()
+ "Controller\\"
+ viewPath.substring(0, viewPath.lastIndexOf("/")).replace("/", "\\")
+ "Controller";
return PhpElementsUtil.getClassMethod(twigFile.getProject(), className, methodName);
}
private static HashMap<String, String> getFormDefaultKeys(
Project project, String formTypeName, HashMap<String, String> defaultValues, int depth) {
PhpClass phpClass = FormUtil.getFormTypeToClass(project, formTypeName);
if (phpClass == null) {
return defaultValues;
}
String typeClass = phpClass.getPresentableFQN();
attachOnDefaultOptions(project, defaultValues, typeClass);
// recursive search for parent form types
PsiElement getParent =
PhpElementsUtil.getPsiElementsBySignatureSingle(
project, "#M#C\\" + phpClass.getPresentableFQN() + ".getParent");
if (getParent != null && depth < 10) {
PhpReturn phpReturn = PsiTreeUtil.findChildOfType(getParent, PhpReturn.class);
if (phpReturn != null) {
PhpPsiElement returnValue = phpReturn.getFirstPsiChild();
if (returnValue instanceof StringLiteralExpression) {
getFormDefaultKeys(
project,
((StringLiteralExpression) returnValue).getContents(),
defaultValues,
depth++);
}
}
}
return defaultValues;
}
@Nullable
@Override
public PsiElement[] getGotoDeclarationTargets(PsiElement psiElement, int offset, Editor editor) {
if (!Symfony2ProjectComponent.isEnabled(psiElement)
|| !PhpElementsUtil.getClassNamePattern().accepts(psiElement)) {
return new PsiElement[0];
}
return ServiceIndexUtil.findServiceDefinitions((PhpClass) psiElement.getContext());
}
private static void attachOnDefaultOptions(
Project project, HashMap<String, String> defaultValues, String typeClass) {
PsiElement setDefaultOptions =
PhpElementsUtil.getPsiElementsBySignatureSingle(
project, "#M#C\\" + typeClass + ".setDefaultOptions");
if (setDefaultOptions == null) {
return;
}
Collection<MethodReference> tests =
PsiTreeUtil.findChildrenOfType(setDefaultOptions, MethodReference.class);
for (MethodReference methodReference : tests) {
// instance check
// methodReference.getSignature().equals("#M#C\\Symfony\\Component\\OptionsResolver\\OptionsResolverInterface.setDefaults")
if (PhpElementsUtil.isEqualMethodReferenceName(methodReference, "setDefaults")) {
PsiElement[] parameters = methodReference.getParameters();
if (parameters.length > 0 && parameters[0] instanceof ArrayCreationExpression) {
for (String key :
PhpElementsUtil.getArrayCreationKeys((ArrayCreationExpression) parameters[0])) {
defaultValues.put(key, typeClass);
}
}
}
// support: parent::setDefaultOptions($resolver)
// Symfony\Component\Form\Extension\Core\Type\FormType:setDefaultOptions
if (PhpElementsUtil.isEqualMethodReferenceName(methodReference, "setDefaultOptions")
&& methodReference.getReferenceType() == PhpModifier.State.PARENT) {
PsiElement parentMethod =
PhpElementsUtil.getPsiElementsBySignatureSingle(
project, methodReference.getSignature());
if (parentMethod instanceof Method) {
PhpClass phpClass = ((Method) parentMethod).getContainingClass();
if (phpClass != null) {
attachOnDefaultOptions(project, defaultValues, phpClass.getPresentableFQN());
}
}
}
}
}
/** new FooClass() */
@Nullable
private static PhpClass getNewExpressionPhpClass(@NotNull NewExpression newExpression) {
ClassReference classReference = newExpression.getClassReference();
if (classReference != null) {
String fqn = classReference.getFQN();
if (fqn != null) {
return PhpElementsUtil.getClass(newExpression.getProject(), fqn);
}
}
return null;
}
public void testCreate() {
DoctrineRepositoryLookupElement element =
DoctrineRepositoryLookupElement.create(
PhpElementsUtil.getClass(getProject(), "\\Foo\\Bar\\BarRepository"));
LookupElementPresentation presentation = new LookupElementPresentation();
element.renderElement(presentation);
assertEquals("Foo\\Bar\\BarRepository", element.getLookupString());
assertEquals(Symfony2Icons.DOCTRINE, presentation.getIcon());
assertEquals("BarRepository", presentation.getItemText());
assertEquals("Foo\\Bar\\BarRepository", presentation.getTypeText());
assertTrue(presentation.isTypeGrayed());
}
@Nullable
public static PsiElement getArrayKeyValueInsideSignaturePsi(
Project project, String signature, String methodName, String keyName) {
PsiElement psiElement = PhpElementsUtil.getPsiElementsBySignatureSingle(project, signature);
if (psiElement == null) {
return null;
}
for (MethodReference methodReference :
PsiTreeUtil.findChildrenOfType(psiElement, MethodReference.class)) {
if (PhpElementsUtil.isEqualMethodReferenceName(methodReference, methodName)) {
PsiElement[] parameters = methodReference.getParameters();
if (parameters.length > 0 && parameters[0] instanceof ArrayCreationExpression) {
return PhpElementsUtil.getArrayValue((ArrayCreationExpression) parameters[0], keyName);
}
}
}
return null;
}
@Nullable
public static PhpClass getPhpClassForCreateCompilerScope(@Nullable PhpClass phpClass) {
if (phpClass == null) {
return null;
}
if (!PhpElementsUtil.isInstanceOf(
phpClass, "\\Symfony\\Component\\HttpKernel\\Bundle\\BundleInterface")) {
return null;
}
return phpClass;
}
private void collectSelectInForm(
QueryBuilderScopeContext qb, MethodReference methodReference, String name) {
// $qb->from('foo', 'select')
if (!"from".equals(name)) {
return;
}
PsiElement psiElement = PsiElementUtils.getMethodParameterPsiElementAt(methodReference, 1);
String literalValue = PhpElementsUtil.getStringValue(psiElement);
if (literalValue != null) {
qb.addSelect(literalValue);
}
}
/**
* Get class by shortcut namespace, on a scoped namespace
*
* @param project current project
* @param classNameScope Namespace fo search "\Foo\Foo", "Foo\Foo", "Foo\Foo\", last "\*" is
* stripped
* @param className Class name inside namespace also fqn is supported
* @return PhpClass matched
*/
public static PhpClass getClassInsideNamespaceScope(
@NotNull Project project, @NotNull String classNameScope, @NotNull String className) {
if (className.startsWith("\\")) {
return PhpElementsUtil.getClassInterface(project, className);
}
// strip class name we namespace
String strip = StringUtils.strip(classNameScope, "\\");
int i = strip.lastIndexOf("\\");
if (i <= 0) {
return PhpElementsUtil.getClassInterface(project, className);
}
PhpClass phpClass =
PhpElementsUtil.getClassInterface(
project, strip.substring(0, i) + "\\" + StringUtils.strip(className, "\\"));
if (phpClass != null) {
return phpClass;
}
return PhpElementsUtil.getClassInterface(project, className);
}
protected PsiElement[] serviceGoToDeclaration(PsiElement psiElement, String serviceId) {
serviceId = YamlHelper.trimSpecialSyntaxServiceName(serviceId).toLowerCase();
String serviceClass =
ContainerCollectionResolver.resolveService(psiElement.getProject(), serviceId);
if (serviceClass != null) {
PsiElement[] targetElements =
PhpElementsUtil.getClassInterfacePsiElements(psiElement.getProject(), serviceClass);
if (targetElements.length > 0) {
return targetElements;
}
}
// get container target on indexes
List<PsiElement> possibleServiceTargets =
ServiceIndexUtil.findServiceDefinitions(psiElement.getProject(), serviceId);
return possibleServiceTargets.toArray(new PsiElement[possibleServiceTargets.size()]);
}
private static void addYamlClassMethods(
@Nullable PsiElement psiElement, CompletionResultSet completionResultSet, String classTag) {
if (psiElement == null) {
return;
}
YAMLKeyValue classKeyValue =
PsiElementUtils.getChildrenOfType(
psiElement, PlatformPatterns.psiElement(YAMLKeyValue.class).withName(classTag));
if (classKeyValue == null) {
return;
}
PhpClass phpClass =
ServiceUtil.getResolvedClassDefinition(
psiElement.getProject(), classKeyValue.getValueText());
if (phpClass != null) {
PhpElementsUtil.addClassPublicMethodCompletion(completionResultSet, phpClass);
}
}
public static Collection<PhpClass> getClassFromPhpTypeSet(Project project, Set<String> types) {
PhpType phpType = new PhpType();
phpType.add(types);
List<PhpClass> phpClasses = new ArrayList<PhpClass>();
for (String typeName :
PhpIndex.getInstance(project)
.completeType(project, phpType, new HashSet<String>())
.getTypes()) {
if (typeName.startsWith("\\")) {
PhpClass phpClass = PhpElementsUtil.getClassInterface(project, typeName);
if (phpClass != null) {
phpClasses.add(phpClass);
}
}
}
return phpClasses;
}
private Map<String, String> findRootDefinition(Collection<MethodReference> methodReferences) {
Map<String, String> roots = new HashMap<String, String>();
if (methodReferences.size() == 0) {
return roots;
}
String rootAlias = null;
String repository = null;
for (MethodReference methodReference : methodReferences) {
String methodReferenceName = methodReference.getName();
// get alias
// ->createQueryBuilder('test');
if ("createQueryBuilder".equals(methodReferenceName)) {
String possibleAlias =
PhpElementsUtil.getStringValue(
PsiElementUtils.getMethodParameterPsiElementAt(methodReference, 0));
if (possibleAlias != null) {
rootAlias = possibleAlias;
}
}
// find repository class
// getRepository('Foo')->createQueryBuilder('test');
if ("getRepository".equals(methodReferenceName)) {
String possibleRepository =
PhpElementsUtil.getStringValue(
PsiElementUtils.getMethodParameterPsiElementAt(methodReference, 0));
if (possibleRepository != null) {
repository = possibleRepository;
PhpClass phpClass = EntityHelper.resolveShortcutName(project, repository);
if (phpClass != null) {
repository = phpClass.getPresentableFQN();
}
}
}
// $qb->from('Foo\Class', 'article')
if ("from".equals(methodReferenceName)) {
String table =
PhpElementsUtil.getStringValue(
PsiElementUtils.getMethodParameterPsiElementAt(methodReference, 0));
String alias =
PhpElementsUtil.getStringValue(
PsiElementUtils.getMethodParameterPsiElementAt(methodReference, 1));
if (table != null && alias != null) {
PhpClass phpClass = EntityHelper.resolveShortcutName(project, table);
if (phpClass != null) {
table = phpClass.getPresentableFQN();
}
roots.put(table, alias);
}
}
}
// we have a valid root so add it
if (rootAlias != null && repository != null) {
roots.put(repository, rootAlias);
}
// we found a alias but not a repository name, so try a scope search if we are inside repository
// class
// class implements \Doctrine\Common\Persistence\ObjectRepository, so search for model name of
// "repositoryClass"
if (rootAlias != null && repository == null) {
MethodReference methodReference = methodReferences.iterator().next();
PhpClass phpClass = PsiTreeUtil.getParentOfType(methodReference, PhpClass.class);
if (new Symfony2InterfacesUtil()
.isInstanceOf(phpClass, "\\Doctrine\\Common\\Persistence\\ObjectRepository")) {
for (DoctrineModel model : EntityHelper.getModelClasses(project)) {
String className = model.getPhpClass().getPresentableFQN();
if (className != null) {
PhpClass resolvedRepoName = EntityHelper.getEntityRepositoryClass(project, className);
if (PhpElementsUtil.isEqualClassName(resolvedRepoName, phpClass.getPresentableFQN())) {
roots.put(className, rootAlias);
return roots;
}
}
}
}
}
// search on PhpTypeProvider
// $er->createQueryBuilder()
if (rootAlias != null && repository == null) {
for (MethodReference methodReference : methodReferences) {
if ("createQueryBuilder".equals(methodReference.getName())) {
String signature = methodReference.getSignature();
int endIndex = signature.lastIndexOf(ObjectRepositoryTypeProvider.TRIM_KEY);
if (endIndex != -1) {
String parameter = signature.substring(endIndex + 1);
int point = parameter.indexOf(".");
if (point > -1) {
parameter = parameter.substring(0, point);
parameter =
PhpTypeProviderUtil.getResolvedParameter(
PhpIndex.getInstance(project), parameter);
if (parameter != null) {
PhpClass phpClass = EntityHelper.resolveShortcutName(project, parameter);
if (phpClass != null && phpClass.getPresentableFQN() != null) {
roots.put(phpClass.getPresentableFQN(), rootAlias);
return roots;
}
}
}
}
}
}
}
return roots;
}
public QueryBuilderScopeContext collect() {
QueryBuilderScopeContext qb = new QueryBuilderScopeContext();
// doctrine needs valid root with an alias, try to find one in method references or scope
Map<String, String> map = this.findRootDefinition(methodReferences);
if (map.size() > 0) {
Map.Entry<String, String> entry = map.entrySet().iterator().next();
qb.addTable(entry.getKey(), entry.getValue());
}
for (MethodReference methodReference : methodReferences) {
String name = methodReference.getName();
if (name != null) {
collectParameter(qb, methodReference, name);
collectJoins(qb, methodReference, name);
collectSelects(qb, methodReference, name);
collectSelectInForm(qb, methodReference, name);
}
}
// first tableMap entry is root, we add several initial data
if (qb.getTableMap().size() > 0) {
Map.Entry<String, String> entry = qb.getTableMap().entrySet().iterator().next();
String className = entry.getKey();
PhpClass phpClass = PhpElementsUtil.getClassInterface(project, className);
// add root select fields
if (phpClass != null) {
qb.addPropertyAlias(
entry.getValue(),
new QueryBuilderPropertyAlias(
entry.getValue(),
null,
new DoctrineModelField(entry.getValue())
.addTarget(phpClass)
.setTypeName(phpClass.getPresentableFQN())));
List<QueryBuilderRelation> relationList = new ArrayList<QueryBuilderRelation>();
// qb.addRelation(entry.getValue(), attachRelationFields(phpClass));
for (DoctrineModelField field : EntityHelper.getModelFields(phpClass)) {
qb.addPropertyAlias(
entry.getValue() + "." + field.getName(),
new QueryBuilderPropertyAlias(entry.getValue(), field.getName(), field));
if (field.getRelation() != null && field.getRelationType() != null) {
relationList.add(new QueryBuilderRelation(field.getName(), field.getRelation()));
}
}
qb.addRelation(entry.getValue(), relationList);
}
QueryBuilderRelationClassResolver resolver =
new QueryBuilderRelationClassResolver(
project, entry.getValue(), entry.getKey(), qb.getRelationMap(), qb.getJoinMap());
resolver.collect();
}
// we have a querybuilder which complete known elements now
// se we can builder a property (field) map table from it
this.buildPropertyMap(qb);
return qb;
}
