public static void ValidateLinks() { foreach (var cachedLink in LinkCache.Cache.Keys) { var link = LinkCache.Cache[cachedLink]; var matches = LinkPattern.Matches(link.Markdown); foreach (Match match in matches) { var name = match.Groups["name"].Value; Type type; try { type = Type.GetType(name); } catch { type = null; } var resolvedLink = LinkCache.ResolveLink(type?.CSharpName() ?? name); resolvedLink = _ResolvePartialTypes(NullablePattern, name, resolvedLink); resolvedLink = _ResolvePartialTypes(TypeParameterPattern, name, resolvedLink); link.Markdown = link.Markdown.Replace($"[{name}]()", resolvedLink); } } }
/// <summary> /// Processes the public constructor overloads. /// </summary> /// <param name="exportedType">The <see cref="DocExportedType"/>.</param> private void ProcessConstructors(DocExportedType exportedType) { if (!exportedType.IsClass) { return; } exportedType.Constructor = new DocConstructor(exportedType) { Name = exportedType.Name, }; var ctors = exportedType.Type.GetConstructors().Concat( exportedType.Type.GetConstructors(BindingFlags.Static | BindingFlags.NonPublic)).Distinct() .OrderBy(c => c.IsStatic ? 1 : 0).ThenBy(c => c.GetParameters().Length); foreach (var ctor in ctors) { var overload = new DocOverload(ctor, exportedType.Constructor) { Name = MemberUtils.GenerateCodeFor(ctor), XPath = MemberUtils.GetSelector(ctor), }; LinkCache.Register(overload); var staticText = ctor.IsStatic ? " static " : " "; overload.Code = $"public{staticText}{overload.Name}"; ProcessParameters(ctor.GetParameters(), overload, overload.Parameters); exportedType.Constructor.Overloads.Add(overload); } }
/// <summary> /// Extracts a link by cross-referencing the type. /// </summary> /// <param name="see">The <see cref="XmlElement"/> with the reference.</param> /// <returns>The extracted link.</returns> public static string ExtractLink(this XmlElement see) { string cref = see.GetAttribute(nameof(cref)); var result = string.Empty; if (!string.IsNullOrEmpty(cref)) { var targets = cref.Split(":"); var text = targets[1]; switch (targets[0]) { case "T": var type = TypeCache.Cache.GetTypeFromName(text); result = Writer.WriteLink(TypeCache.Cache[type]); break; case "P": var link = LinkCache.GetLinkBySelector(cref); result = link ?? $"`{FriendlyDisplayType(text)}`"; break; default: var refLink = LinkCache.GetLinkBySelector(cref); if (refLink == null) { // assume it is a Microsoft reference string baseHref, methodExt = string.Empty; var parts = text.Split('.').ToList(); var method = parts.FirstOrDefault(p => p.Contains("(")); if (!string.IsNullOrEmpty(method)) { baseHref = string.Join( '.', parts.GetRange(0, parts.IndexOf(method))); methodExt = NameOnly(method.Split('(')[0]); } else { baseHref = text; } link = baseHref.Replace('`', '-'); var linkText = FriendlyDisplayType(baseHref); if (!string.IsNullOrWhiteSpace(methodExt)) { link += $".{methodExt}"; linkText += $".{methodExt}"; } result = Writer.WriteLink(linkText, $"{TypeCache.MsftApiBaseRef}{link}"); } break; } } return(result); }
/// <summary> /// Process type information. /// </summary> /// <param name="type">The <see cref="Type"/> to process.</param> /// <param name="target">The <see cref="DocBaseType"/> to process to.</param> private void ProcessType(Type type, DocBaseType target) { target.Name = type.FullName ?? $"{type.Namespace}.{type.Name}"; target.Type = type; target.IsInterface = type.IsInterface; target.IsEnum = type.IsEnum; target.XPath = MemberUtils.GetSelector(type); LinkCache.Register(target); }
public FormMain() { InitializeComponent(); linkCache = new LinkCache(); Clear(); LoadLinks(); CheckLinks(); ShowLinks(); ShowLinkStatus(linkCache.Links, "Loaded"); }
protected void CreateLink(Action <Link> action) { var link = new Link { ObjId = Guid.NewGuid() }; action.Invoke(link); LinkCache.Add(link.ObjId, link); }
private static string _ResolvePartialTypes(Regex pattern, string name, string resolvedLink) { var matches = pattern.Matches(name); if (matches.FirstOrDefault()?.Groups["name"].Success ?? false) { var nameComponent = matches[0].Groups["name"].Value; var componentLink = LinkCache.ResolveLink(nameComponent); if (nameComponent != componentLink) { return(resolvedLink.Replace(nameComponent, componentLink)); } } return(resolvedLink); }
protected virtual PXSetPropertyException CanBeLinkDeleted(OrganizationLedgerLink link) { Ledger ledger = GeneralLedgerMaint.FindLedgerByID(Base, link.LedgerID); if (ledger.BalanceType == LedgerBalanceType.Actual) { if (GLUtility.RelatedGLHistoryExists(Base, link.LedgerID, link.OrganizationID)) { Organization org = OrganizationMaint.FindOrganizationByID(Base, link.OrganizationID, true); return(new PXSetPropertyException(Messages.TheRelationBetweenTheLedgerAndTheCompanyCannotBeRemovedBecauseAtLeastOneGeneralLedgerTransactionHasBeenPosted, PXErrorLevel.RowError, LinkCache.GetValueExt <OrganizationLedgerLink.ledgerID>(link), org.OrganizationCD.Trim() )); } } return(null); }
/// <summary> /// Processes the public method overloads. /// </summary> /// <param name="exportedType">The <see cref="DocExportedType"/>.</param> private void ProcessMethods(DocExportedType exportedType) { var typePropertyMethods = exportedType.Type.GetProperties() .Select(p => new[] { p.GetMethod, p.SetMethod }) .SelectMany(p => p) .Where(p => p != null) .Distinct(); var typeMethods = exportedType.Type.GetMethods( BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).Where(m => m.DeclaringType == exportedType.Type) .Except(typePropertyMethods); foreach (var methodInfo in typeMethods) { var method = exportedType.Methods.FirstOrDefault(m => m.Name == methodInfo.Name); if (method == null) { method = new DocMethod(exportedType) { Name = methodInfo.Name, MethodReturnType = TypeCache.Cache[methodInfo.ReturnType], }; exportedType.Methods.Add(method); } var methodOverload = new DocMethodOverload(methodInfo, method) { Name = MemberUtils.GenerateCodeFor(methodInfo), XPath = MemberUtils.GetSelector(methodInfo), }; LinkCache.Register(methodOverload); methodOverload.Code = methodOverload.Name; ProcessParameters(methodInfo.GetParameters(), methodOverload, methodOverload.Parameters); method.MethodOverloads.Add(methodOverload); } }
/// <summary> /// Process property information. /// </summary> /// <param name="exportedType">The <see cref="DocExportedType"/> to parse.</param> private void ProcessProperties(DocExportedType exportedType) { var defaultRules = typeof(DefaultComparisonRules); foreach (var prop in exportedType.Type.GetProperties( BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) { if (prop.DeclaringType != exportedType.Type) { continue; } var property = new DocProperty(exportedType) { Name = $"{exportedType.Name}.{prop.Name}", XPath = MemberUtils.GetSelector(prop), Type = prop.PropertyType, TypeParameters = ProcessTypeParameters(prop.PropertyType), Code = MemberUtils.GenerateCodeFor(prop), }; if (exportedType.Type == defaultRules && prop.GetMethod.IsStatic) { var expression = prop.GetMethod.Invoke(null, null); property.CustomInfo = expression.ToString(); } LinkCache.Register(property); if (prop.GetIndexParameters().Length > 0) { property.IsIndexer = true; property.IndexerType = TypeCache.Cache[prop.GetIndexParameters().First().ParameterType]; } property.TypeParameter = exportedType.TypeParameters.FirstOrDefault( t => t.Name == property.Type.Name); exportedType.Properties.Add(property); } }
public virtual IEnumerable deleteOrganizationLedgerLink(PXAdapter adapter) { var link = LinkCache.Current as OrganizationLedgerLink; if (link?.OrganizationID == null || link.LedgerID == null) { return(adapter.Get()); } Ledger ledger = GeneralLedgerMaint.FindLedgerByID(Base, link.LedgerID); if (ledger.BalanceType == LedgerBalanceType.Actual) { LinkCache.Delete(link); } else { if (GLUtility.RelatedGLHistoryExists(Base, link.LedgerID, link.OrganizationID)) { Organization org = OrganizationMaint.FindOrganizationByID(Base, link.OrganizationID, true); WebDialogResult dialogResult = OrganizationLedgerLinkSelect.Ask(PXMessages.LocalizeFormatNoPrefix( Messages.AtLeastOneGeneralLedgerTransactionHasBeenPosted, LinkCache.GetValueExt <OrganizationLedgerLink.ledgerID>(link).ToString().Trim(), org.OrganizationCD.Trim()), MessageButtons.YesNo); if (dialogResult == WebDialogResult.Yes) { LinkCache.Delete(link); } } else { LinkCache.Delete(link); } } return(adapter.Get()); }