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());
}
