internal override void AnalyzeCompilation(CompilationStartAnalysisContext compilationStartContext, PXContext pxContext) { compilationStartContext.RegisterSymbolAction(c => Analyze(c, pxContext), SymbolKind.Method); }
private static ViewSymbolWithTypeCollection GetViewsFromGraphImpl(this ITypeSymbol graph, PXContext pxContext, bool includeViewsFromInheritanceChain = true) { if (includeViewsFromInheritanceChain) { return(graph.GetBaseTypesAndThis() .TakeWhile(baseGraph => !baseGraph.IsGraphBaseType()) .Reverse() .SelectMany(baseGraph => GetAllViewSymbolsWithTypesFromPXGraphOrPXGraphExtensionImpl(baseGraph, pxContext))); } else { return(GetAllViewSymbolsWithTypesFromPXGraphOrPXGraphExtensionImpl(graph, pxContext)); } }
private Task <Document> AddPrimaryKeyDeclarationToDacAsync(Document document, SyntaxNode root, ClassDeclarationSyntax dacNode, PXContext pxContext, INamedTypeSymbol dacTypeSymbol, CancellationToken cancellation) { cancellation.ThrowIfCancellationRequested(); var dacSemanticModel = DacSemanticModel.InferModel(pxContext, dacTypeSymbol, cancellation); List <DacPropertyInfo> dacKeys = dacSemanticModel?.DacProperties .Where(property => property.IsKey) .OrderBy(property => property.DeclarationOrder) .ToList(capacity: 4); if (dacKeys.IsNullOrEmpty() || dacKeys.Count > PXReferentialIntegritySymbols.MaxPrimaryKeySize) { return(Task.FromResult(document)); } var primaryKeyNode = CreatePrimaryKeyNode(document, pxContext, dacSemanticModel, dacKeys); var newDacNode = dacNode.WithMembers( dacNode.Members.Insert(0, primaryKeyNode)); var changedRoot = root.ReplaceNode(dacNode, newDacNode); changedRoot = AddUsingsForReferentialIntegrityNamespace(changedRoot); var modifiedDocument = document.WithSyntaxRoot(changedRoot); return(Task.FromResult(modifiedDocument)); }
/// <summary> /// Gets the graph type from graph extension type. /// </summary> /// <param name="graphExtension">The graph extension to act on.</param> /// <param name="pxContext">Context.</param> /// <returns> /// The graph from graph extension. /// </returns> public static ITypeSymbol GetGraphFromGraphExtension(this ITypeSymbol graphExtension, PXContext pxContext) { pxContext.ThrowOnNull(nameof(pxContext)); if (graphExtension == null || !graphExtension.InheritsFrom(pxContext.PXGraphExtensionType)) { return(null); } var baseGraphExtensionType = graphExtension.GetBaseTypesAndThis() .OfType <INamedTypeSymbol>() .FirstOrDefault(type => type.IsGraphExtensionBaseType()); if (baseGraphExtensionType == null) { return(null); } var graphExtTypeArgs = baseGraphExtensionType.TypeArguments; if (graphExtTypeArgs.Length == 0) { return(null); } ITypeSymbol firstTypeArg = graphExtTypeArgs.Last(); return(firstTypeArg.IsPXGraph(pxContext) ? firstTypeArg : null); }
public override bool ShouldAnalyze(PXContext pxContext, PXGraphSemanticModel graph) => base.ShouldAnalyze(pxContext, graph) && graph.Type == GraphType.PXGraphExtension && !graph.Symbol.InstanceConstructors.IsDefaultOrEmpty && !graph.Symbol.IsGraphExtensionBaseType();
private MethodDeclarationSyntax MakeFindMethodNode(SyntaxGenerator generator, PXContext pxContext, DacSemanticModel dacSemanticModel, List <DacPropertyInfo> dacKeys) { var returnType = generator.TypeExpression(dacSemanticModel.Symbol); var parameters = MakeParameterNodesForFindMethod(generator, pxContext, dacSemanticModel, dacKeys); var findMethodNode = generator.MethodDeclaration(DelegateNames.PrimaryKeyFindMethod, parameters, typeParameters: null, returnType, Accessibility.Public, DeclarationModifiers.Static) as MethodDeclarationSyntax; if (findMethodNode.Body != null) { findMethodNode = findMethodNode.RemoveNode(findMethodNode.Body, SyntaxRemoveOptions.KeepNoTrivia); } var findByCallArguments = parameters.OfType <ParameterSyntax>() .Select(parameter => Argument( IdentifierName(parameter.Identifier))); var findByInvocation = generator.InvocationExpression( IdentifierName(DelegateNames.PrimaryKeyFindByMethod), findByCallArguments) as InvocationExpressionSyntax; bool statementTooLongForOneLine = dacKeys.Count > MaxNumberOfKeysForOneLineStatement; if (statementTooLongForOneLine) { var trivia = dacSemanticModel.Node.GetLeadingTrivia() .Add(Whitespace("\t\t")) .Where(trivia => trivia.IsKind(SyntaxKind.WhitespaceTrivia)); findByInvocation = findByInvocation.WithLeadingTrivia(trivia); } var arrowExpression = ArrowExpressionClause(findByInvocation); if (statementTooLongForOneLine) { arrowExpression = arrowExpression.WithArrowToken( Token(SyntaxKind.EqualsGreaterThanToken) .WithTrailingTrivia(Whitespace(" "), EndOfLine(Environment.NewLine))); } return(findMethodNode.WithExpressionBody(arrowExpression) .WithSemicolonToken( Token(SyntaxKind.SemicolonToken))); }
public override bool ShouldAnalyze(PXContext pxContext, DacSemanticModel dac) => base.ShouldAnalyze(pxContext, dac) && dac.DacType == DacType.DacExtension && dac.Symbol.Name != TypeNames.PXCacheExtension && !dac.Symbol.InheritsFromOrEquals(pxContext.PXMappedCacheExtensionType);
public override bool ShouldAnalyze(PXContext pxContext, PXGraphSemanticModel graph) => graph.Type == GraphType.PXGraph;
/// <summary> /// Gets all declared view symbols and types from the graph and its base graphs, /// if there is a graphs class hierarchy and <paramref name="includeViewsFromInheritanceChain"/> parameter is <c>true</c>. /// </summary> /// <param name="graph">The graph to act on.</param> /// <param name="pxContext">Context.</param> /// <param name="includeViewsFromInheritanceChain">(Optional) True to include, false to exclude the views from inheritance chain.</param> /// <returns/> public static ViewOverridableCollection GetViewsWithSymbolsFromPXGraph(this ITypeSymbol graph, PXContext pxContext, bool includeViewsFromInheritanceChain = true) { pxContext.ThrowOnNull(nameof(pxContext)); if (graph?.InheritsFrom(pxContext.PXGraph.Type) != true) { return(Enumerable.Empty <GraphOverridableItem <(ISymbol, INamedTypeSymbol)> >()); } var viewsByName = new GraphOverridableItemsCollection <(ISymbol Symbol, INamedTypeSymbol Type)>(); var graphViews = GetViewsFromGraphImpl(graph, pxContext, includeViewsFromInheritanceChain); viewsByName.AddRangeWithDeclarationOrder(graphViews, startingOrder: 0, keySelector: view => view.Symbol.Name); return(viewsByName.Items); }
/// <summary> /// Get all views from graph or graph extension and its base graphs and base graph extensions (extended via Acumatica Customization). /// </summary> /// <param name="graphOrExtension">The graph Or graph extension to act on.</param> /// <param name="pxContext">Context.</param> /// <returns/> public static ViewOverridableCollection GetViewsFromGraphOrGraphExtensionAndBaseGraph(this ITypeSymbol graphOrExtension, PXContext pxContext) { pxContext.ThrowOnNull(nameof(pxContext)); graphOrExtension.ThrowOnNull(nameof(graphOrExtension)); bool isGraph = graphOrExtension.IsPXGraph(pxContext); if (!isGraph && !graphOrExtension.IsPXGraphExtension(pxContext)) { return(Enumerable.Empty <GraphOverridableItem <(ISymbol, INamedTypeSymbol)> >()); } return(isGraph ? graphOrExtension.GetViewsWithSymbolsFromPXGraph(pxContext) : graphOrExtension.GetViewsFromGraphExtensionAndBaseGraph(pxContext)); }
private static IEnumerable <GraphOverridableItem <T> > GetViewInfoFromGraphExtension <T>(ITypeSymbol graphExtension, PXContext pxContext, AddViewInfoWithOrderDelegate <T> addGraphViewInfo, AddViewInfoWithOrderDelegate <T> addGraphExtensionViewInfo) { var empty = Enumerable.Empty <GraphOverridableItem <T> >(); if (!graphExtension.InheritsFrom(pxContext.PXGraphExtensionType) || !graphExtension.BaseType.IsGenericType) { return(empty); } var graphType = graphExtension.GetGraphFromGraphExtension(pxContext); if (graphType == null) { return(empty); } var allExtensionsFromBaseToDerived = graphExtension.GetGraphExtensionWithBaseExtensions(pxContext, SortDirection.Ascending, includeGraph: false); if (allExtensionsFromBaseToDerived.IsNullOrEmpty()) { return(empty); } var infoByView = new GraphOverridableItemsCollection <T>(); int declarationOrder = addGraphViewInfo(infoByView, graphType, startingOrder: 0); foreach (ITypeSymbol extension in allExtensionsFromBaseToDerived) { declarationOrder = addGraphExtensionViewInfo(infoByView, extension, declarationOrder); } return(infoByView.Items); }
/// <summary> /// Get the view delegates symbols and syntax nodes from the graph. /// The <paramref name="viewsByName"/> must have <see cref="StringComparer.OrdinalIgnoreCase"/> comparer. /// </summary> /// <param name="graph">The graph to act on</param> /// <param name="viewsByName">The views of the graph dictionary with <see cref="StringComparer.OrdinalIgnoreCase"/> comparer</param> /// <param name="pxContext">Context</param> /// <param name="cancellation">Cancellation token</param> /// <param name="inheritance">If true includes view delegates from the graph inheritance chain</param> /// <returns></returns> public static DataViewDelegatesOverridableCollection GetViewDelegatesFromGraph(this ITypeSymbol graph, IDictionary <string, DataViewInfo> viewsByName, PXContext pxContext, CancellationToken cancellation, bool inheritance = true) { graph.ThrowOnNull(nameof(graph)); viewsByName.ThrowOnNull(nameof(viewsByName)); pxContext.ThrowOnNull(nameof(pxContext)); if (!graph.IsPXGraph(pxContext)) { return(Enumerable.Empty <GraphOverridableItem <(MethodDeclarationSyntax, IMethodSymbol)> >()); } var viewDelegatesByName = new GraphOverridableItemsCollection <(MethodDeclarationSyntax Node, IMethodSymbol Symbol)>(); var graphViewDelegates = GetViewDelegatesFromGraphImpl(graph, viewsByName, pxContext, inheritance, cancellation); viewDelegatesByName.AddRangeWithDeclarationOrder(graphViewDelegates, startingOrder: 0, keySelector: viewDel => viewDel.Symbol.Name); return(viewDelegatesByName.Items); }
private static ViewSymbolWithTypeCollection GetAllViewSymbolsWithTypesFromPXGraphOrPXGraphExtensionImpl(ITypeSymbol graphOrExtension, PXContext pxContext) { foreach (ISymbol member in graphOrExtension.GetMembers()) { if (!(member is IFieldSymbol field) || field.DeclaredAccessibility != Accessibility.Public) { continue; } if (!(field.Type is INamedTypeSymbol fieldType) || !fieldType.InheritsFrom(pxContext.PXSelectBase.Type)) { continue; } yield return(field, fieldType); } }
void IPrefetchable <PXWizardSiteMapProvider> .Prefetch(PXWizardSiteMapProvider provider) { PXContext.SetSlot("PrefetchSiteMap", true); Dictionary <Guid, WZScenario> wizardScenarios = GetWizardScenarios(); base.Prefetch(provider); // Main site map if (!PXSiteMap.IsPortal) { foreach (Guid scenarioID in wizardScenarios.Keys) { List <string> scenarioRole = new List <string>(); if (!String.IsNullOrEmpty(wizardScenarios[scenarioID].Rolename)) { scenarioRole.Add(wizardScenarios[scenarioID].Rolename); } // If scenario is not active we should use different graph bool scenarioIsActive = wizardScenarios[scenarioID].Status == WizardScenarioStatusesAttribute._ACTIVE; PXSiteMapNode node, rootScenarioNode; if (scenarioIsActive) { node = base.FindSiteMapNodesFromGraphType(typeof(WizardScenarioMaint).FullName, false).FirstOrDefault(); } else { node = base.FindSiteMapNodesFromGraphType(typeof(WizardNotActiveScenario).FullName, false).FirstOrDefault(); } string url = PXSiteMap.DefaultFrame; if (node != null) { url = String.Format("{0}?ScenarioID={1}", node.Url, System.Web.HttpUtility.UrlEncode(scenarioID.ToString())); } rootScenarioNode = base.FindSiteMapNodesFromScreenID(WizardRootNode, false).FirstOrDefault(); PXSiteMapNode scenarioNode = CreateWizardNode(provider, scenarioID, url, wizardScenarios[scenarioID].Name, wizardScenarios[scenarioID].Name, new PXRoleList(scenarioRole.Count == 0 ? null : scenarioRole, null, null), null, false, "WZ201500"); if (wizardScenarios[scenarioID].NodeID != Guid.Empty) { if (scenarioIsActive) { if (rootScenarioNode != null && rootScenarioNode.NodeID == (Guid)wizardScenarios[scenarioID].NodeID) { PXSiteMapNode DummyNode = base.FindSiteMapNodesFromScreenID("WZ000001", false).FirstOrDefault(); if (DummyNode == null) { DummyNode = CreateWizardNode(provider, Guid.NewGuid(), PXSiteMap.DefaultFrame, "Work Area", "Work Area", null, null, true, "WZ000001"); AddNode(DummyNode, rootScenarioNode.NodeID); } AddNode(scenarioNode, DummyNode.NodeID); } else { AddNode(scenarioNode, (Guid)wizardScenarios[scenarioID].NodeID); } } else { PXSiteMapNode HiddenNode = base.FindSiteMapNodesFromScreenID("HD000000", false).FirstOrDefault(); AddNode(scenarioNode, HiddenNode.NodeID); } } else { if (scenarioIsActive) { if (rootScenarioNode != null) { PXSiteMapNode DummyNode = base.FindSiteMapNodesFromScreenID("WZ000001", false).FirstOrDefault(); if (DummyNode == null) { DummyNode = CreateWizardNode(provider, Guid.NewGuid(), PXSiteMap.DefaultFrame, "Work Area", "Work Area", null, null, true, "WZ000001"); AddNode(DummyNode, rootScenarioNode.NodeID); } AddNode(scenarioNode, DummyNode.NodeID); } } else { PXSiteMapNode HiddenNode = base.FindSiteMapNodesFromScreenID("HD000000", false).FirstOrDefault(); AddNode(scenarioNode, HiddenNode.NodeID); } } } } PXContext.SetSlot("PrefetchSiteMap", false); }
private static void CheckIdentifierForUnderscores(SyntaxToken identifier, SymbolAnalysisContext context, PXContext pxContext) { if (!identifier.ValueText.Contains("_")) { return; } bool registerCodeFix = !IdentifierContainsOnlyUnderscores(identifier.ValueText); var diagnosticProperties = new Dictionary <string, string> { { DiagnosticProperty.RegisterCodeFix, registerCodeFix.ToString() } }.ToImmutableDictionary(); context.ReportDiagnosticWithSuppressionCheck( Diagnostic.Create(Descriptors.PX1026_UnderscoresInDacDeclaration, identifier.GetLocation(), diagnosticProperties), pxContext.CodeAnalysisSettings); }
protected void Page_Init(object sender, EventArgs e) { // remove unum parameter PropertyInfo isreadonly = typeof(System.Collections.Specialized.NameValueCollection).GetProperty("IsReadOnly", BindingFlags.Instance | BindingFlags.NonPublic); // make collection editable isreadonly.SetValue(this.Request.QueryString, false, null); this.Request.QueryString.Remove(PXUrl.UNum); isreadonly.SetValue(this.Request.QueryString, true, null); this.usrCaption.CustomizationAvailable = false; var date = PXContext.GetBusinessDate(); PX.Common.PXContext.SetBusinessDate((DateTime?)date); if ((this.viewer.SchemaUrl = this.Request.QueryString["ID"]) == null) { this.viewer.SchemaUrl = ReportID; } if (SiteMap.CurrentNode != null) { this.Title = PXSiteMap.CurrentNode.Title; _screenID = PXSiteMap.CurrentNode.ScreenID; } else { string url; if (Request.ApplicationPath != "/") { url = Request.Path.Replace(Request.ApplicationPath, "~") + "?ID=" + this.viewer.SchemaUrl; } else if (Request.Path.StartsWith("/")) { url = "~" + Request.Path; } else { url = Request.Path; } PXSiteMapNode node = SiteMap.Provider.FindSiteMapNode(url) as PXSiteMapNode; if (node != null) { this.Title = node.Title; this.usrCaption.ScreenTitle = node.Title; this.usrCaption.ScreenID = PX.Common.Mask.Format(">CC.CC.CC.CC", node.ScreenID); _screenID = node.ScreenID; } else { using (PXDataRecord record = PXDatabase.SelectSingle <PX.SM.SiteMap>( new PXDataField("ScreenID"), new PXDataFieldValue("Url", PXDbType.VarChar, 512, url) )) { if (record != null) { _screenID = record.GetString(0); if (!String.IsNullOrEmpty(_screenID) && !PXAccess.VerifyRights(_screenID)) { throw new PXSetPropertyException(ErrorMessages.NotEnoughRights, this.viewer.SchemaUrl); } } } } } if (String.IsNullOrEmpty(PX.Common.PXContext.GetScreenID())) { if (String.IsNullOrEmpty(_screenID) && !String.IsNullOrEmpty(this.viewer.SchemaUrl)) { string schema = this.viewer.SchemaUrl; if (schema.EndsWith(".rpx", StringComparison.OrdinalIgnoreCase)) { schema = schema.Substring(0, schema.Length - 4); } if (schema.Length == 8) { _screenID = schema; } } if (!String.IsNullOrEmpty(_screenID)) { PX.Common.PXContext.SetScreenID(PX.Common.Mask.Format(">CC.CC.CC.CC", _screenID)); } } if (_canSendEmail) { viewer.EmailSend += new PXReportViewer.EmailSendHandler(viewer_EmailSend); } else { viewer.AllowSendEmails = false; } }
public Rewriter(PXContext pxContext, Document document, SemanticModel semanticModel) { _pxContext = pxContext; _document = document; _semanticModel = semanticModel; }
public DiagnosticWalker(SymbolAnalysisContext context, SemanticModel semanticModel, PXContext pxContext, ImmutableArray <ILocalSymbol> rowVariables, // variables which were assigned with e.Row params object[] messageArgs) { pxContext.ThrowOnNull(nameof(pxContext)); semanticModel.ThrowOnNull(nameof(semanticModel)); _context = context; _semanticModel = semanticModel; _pxContext = pxContext; _rowVariables = rowVariables.ToImmutableHashSet(); _messageArgs = messageArgs; _variableMemberAccessWalker = new VariableMemberAccessWalker(_rowVariables, semanticModel); }
//--------------------------------------------------------------------------- /// <summary> /// The page Init event handler. /// </summary> protected void Page_Init(object sender, EventArgs e) { var lifetimeScope = this.Context.GetLifetimeScope(); if (lifetimeScope != null) { screenRepository = lifetimeScope.Resolve <IScreenRepository>(); } else { var serviceLocator = ServiceLocator.Current; screenRepository = serviceLocator.GetInstance <IScreenRepository>(); } JSManager.RegisterModule(new MSScriptRenderer(Page.ClientScript), typeof(AppJS), AppJS.PageTitle); if (screenID == null) { this.screenID = ControlHelper.GetScreenID(); } if (screenTitle == null) { if (System.Web.SiteMap.CurrentNode != null) { if (company == null || System.Web.SiteMap.CurrentNode.ParentNode != null) { screenTitle = PXSiteMap.CurrentNode.Title; } else { screenTitle = company; } } } string hide = this.Page.Request.QueryString[PXUrl.HidePageTitle]; if (!string.IsNullOrEmpty(hide)) { this.Visible = false; return; } this.Page.InitComplete += new EventHandler(Page_InitComplete); PXCallbackManager.GetInstance().PreGetCallbackResult += PreGetCallbackResult; tlbPath.Items["syncTOC"].Visible = false; tlbPath.Items["branch"].Visible = false; if (!this.Page.IsCallback) { ((WebControl)LabelScreen.Parent).CssClass = "pageTitleCont"; } if (PXDataSource.RedirectHelper.IsPopupPage(Page)) { if (!PXList.Provider.HasList(PXSiteMap.CurrentNode.ScreenID)) { tlbPath.Items["syncTOC"].Visible = false; } this.FavoriteAvailable = false; if (!PXDataSource.RedirectHelper.IsPopupInline(Page)) { GetBranchCombo().Enabled = false; } } if (PXSiteMap.IsPortal) { this.CustomizationAvailable = PXAccess.GetAdministratorRoles().Any(System.Web.Security.Roles.IsUserInRole); this.BranchAvailable = false; this.FavoriteAvailable = false; pnlTBR.CssClass = "panelTBRSP"; } if (PXContext.PXIdentity.Authenticated) { userName = PXContext.PXIdentity.IdentityName; string branch = PXAccess.GetBranchCD(); if (!string.IsNullOrEmpty(branch)) { userName += ":" + branch; } } var date = PXContext.GetBusinessDate(); if (date != null) { PXDateTimeEdit.SetDefaultDate((DateTime)date); } if (!Page.IsCallback) { Session.Remove("StoredSearch"); } Page.Header.Controls.Add( new System.Web.UI.LiteralControl("<link rel=\"stylesheet\" type=\"text/css\" href=\"" + ResolveUrl("~/Content/AcuInsight.css") + "\" />")); }
public Walker(SymbolAnalysisContext context, PXContext pxContext, SemanticModel semanticModel) { _context = context; _pxContext = pxContext; _semanticModel = semanticModel; }
protected void Page_Load(object sender, EventArgs e) { applicationName = Request.ApplicationPath.TrimEnd('/'); pageUrl = SharedFunctions.GetWebMethodPath(Request.Path); DateTime?startDateBridge; var date = PXContext.GetBusinessDate(); startDateBridge = (date != null) ? date : PXTimeZoneInfo.Now; // Filter By RefNbr RefNbr = Request.QueryString["RefNbr"]; // External CustomerID CustomerID = Request.QueryString["CustomerID"]; // Employee ExternalEmployee = String.IsNullOrEmpty(Request.QueryString["EmployeeID"]) == false ? Request.QueryString["EmployeeID"] : Request.QueryString["bAccountID"]; // External SMEquipmentID SMEquipmentID = Request.QueryString["SMEquipmentID"]; // Focus unassigned Appointment Tab AppSource = Request.QueryString["AppSource"]; ExternalBranchID = Request.QueryString["branchID"]; ExternalBranchLocationID = Request.QueryString["branchLocationID"]; // Date try { if (!String.IsNullOrEmpty(Request.QueryString["Date"])) { startDateBridge = Convert.ToDateTime(Request.QueryString["Date"]); } } catch (Exception) { } var graphExternalControls = PXGraph.CreateInstance <ExternalControls>(); var results = graphExternalControls.EmployeeSelected.Select(); startDate = ((DateTime)startDateBridge).ToString("MM/dd/yyyy h:mm:ss tt", new CultureInfo("en-US")); PXResult <EPEmployee, Contact> result = (PXResult <EPEmployee, Contact>)results; EPEmployee epEmployeeRow = result; if (epEmployeeRow != null) { DefaultEmployee = epEmployeeRow.BAccountID.ToString(); } if (string.IsNullOrEmpty(ExternalEmployee) && epEmployeeRow != null) { ExternalEmployee = DefaultEmployee; } // Load Appointment's Body to be used in index.aspx StreamReader streamReader = new StreamReader(Server.MapPath("../../Shared/templates/EventTemplate.html")); appointmentBodyTemplate = streamReader.ReadToEnd(); streamReader.Close(); // Load Service Order's ToolTip to be used in index.aspx streamReader = new StreamReader(Server.MapPath("../../Shared/templates/TooltipServiceOrder.html")); toolTipTemplateServiceOrder = streamReader.ReadToEnd(); streamReader.Close(); // Load Appointment's ToolTip to be used in index.aspx streamReader = new StreamReader(Server.MapPath("../../Shared/templates/TooltipAppointment.html")); toolTipTemplateAppointment = streamReader.ReadToEnd(); streamReader.Close(); }
private List <SyntaxNode> MakeParameterNodesForFindMethod(SyntaxGenerator generator, PXContext pxContext, DacSemanticModel dacSemanticModel, List <DacPropertyInfo> dacKeys) { const string graphParameterName = "graph"; var graphParameter = generator.ParameterDeclaration(graphParameterName, generator.TypeExpression(pxContext.PXGraph.Type)); var parameters = new List <SyntaxNode>(capacity: dacKeys.Count + 1) { graphParameter }; foreach (DacPropertyInfo keyProperty in dacKeys) { DacFieldInfo keyField = dacSemanticModel.FieldsByNames[keyProperty.Name]; var parameterType = generator.TypeExpression(keyProperty.PropertyType); var parameterNode = generator.ParameterDeclaration(keyField.Name, parameterType); parameters.Add(parameterNode); } return(parameters); }
public override bool ShouldAnalyze(PXContext pxContext, PXGraphSemanticModel graph) => base.ShouldAnalyze(pxContext, graph) && graph.Type != GraphType.None;
/// <summary> /// Get declared primary DAC from graph or graph extension. /// </summary> /// <param name="graphOrExtension">The graph or graph extension to act on.</param> /// <param name="pxContext">Context.</param> /// <returns> /// The declared primary DAC from graph or graph extension. /// </returns> public static ITypeSymbol GetDeclaredPrimaryDacFromGraphOrGraphExtension(this ITypeSymbol graphOrExtension, PXContext pxContext) { pxContext.ThrowOnNull(nameof(pxContext)); bool isGraph = graphOrExtension?.InheritsFrom(pxContext.PXGraph.Type) ?? false; if (!isGraph && !graphOrExtension?.InheritsFrom(pxContext.PXGraphExtensionType) != true) { return(null); } ITypeSymbol graph = isGraph ? graphOrExtension : graphOrExtension.GetGraphFromGraphExtension(pxContext); var baseGraphType = graph.GetBaseTypesAndThis() .OfType <INamedTypeSymbol>() .FirstOrDefault(type => IsGraphWithPrimaryDacBaseGenericType(type)) as INamedTypeSymbol; if (baseGraphType == null || baseGraphType.TypeArguments.Length < 2) { return(null); } ITypeSymbol primaryDacType = baseGraphType.TypeArguments[1]; return(primaryDacType.IsDAC() ? primaryDacType : null); }
public ParametersCounterSyntaxWalker(SyntaxNodeAnalysisContext aSyntaxContext, PXContext aPxContext) { _syntaxContext = aSyntaxContext; _cancellationToken = _syntaxContext.CancellationToken; ParametersCounter = new ParametersCounter(aPxContext); }
public Walker(SymbolAnalysisContext context, PXContext pxContext, EventType eventType) : base(context, pxContext) { _eventType = eventType; }
public void Dispose() { PXContext.SetSlot <RunningSelectingScope <DAC> >(_Previous); }
private static (AttributeData PXDefaultAttribute, bool HasPersistingCheckNothing) GetPXDefaultInfo(PXContext pxContext, DacPropertyInfo property) { var defaultAttributes = property.Attributes.Where(a => a.IsDefaultAttribute).ToList(); if (defaultAttributes.Count != 1) //We don't check in case of multiple pxdefault { return(null, false); } var pxDefaultAttribute = defaultAttributes[0].AttributeData; var hasPersistingCheckNothing = (from arg in pxDefaultAttribute.NamedArguments where TypeNames.PersistingCheck.Equals(arg.Key, StringComparison.Ordinal) select arg.Value.Value) .Any(value => value is int persistingCheck && persistingCheck == (int)PXPersistingCheckValues.Nothing); return(pxDefaultAttribute, hasPersistingCheckNothing); }
/// <summary> /// Get all view symbols and types from the graph extension and its base graph /// </summary> /// <param name="graphExtension">The graph extension to act on</param> /// <param name="pxContext">Context</param> /// <returns></returns> public static ViewOverridableCollection GetViewsFromGraphExtensionAndBaseGraph(this ITypeSymbol graphExtension, PXContext pxContext) { graphExtension.ThrowOnNull(nameof(graphExtension)); pxContext.ThrowOnNull(nameof(pxContext)); return(GetViewInfoFromGraphExtension <(ISymbol, INamedTypeSymbol)>(graphExtension, pxContext, AddViewsFromGraph, AddViewsFromGraphExtension)); int AddViewsFromGraph(GraphOverridableItemsCollection <(ISymbol Symbol, INamedTypeSymbol Type)> views, ITypeSymbol graph, int startingOrder) { var graphViews = graph.GetViewsFromGraphImpl(pxContext); return(views.AddRangeWithDeclarationOrder(graphViews, startingOrder, keySelector: v => v.Symbol.Name)); } int AddViewsFromGraphExtension(GraphOverridableItemsCollection <(ISymbol Symbol, INamedTypeSymbol Type)> views, ITypeSymbol graphExt, int startingOrder) { var extentionsViews = GetAllViewSymbolsWithTypesFromPXGraphOrPXGraphExtensionImpl(graphExt, pxContext); return(views.AddRangeWithDeclarationOrder(extentionsViews, startingOrder, keySelector: v => v.Symbol.Name)); } }