private void SetTemplateData_ReturnType(ApiMethodObj methodItem, MethodXmlElement xmlMethodObj, ref StringBuilder sbr_mdFileForMethod)
{
string returnText = TemplateConsts.TEXT_NONE;
if (xmlMethodObj != null && !string.IsNullOrEmpty(xmlMethodObj.Returns))
{
returnText = xmlMethodObj.Returns;
}
else if (methodItem.ReturnType != null)
{
returnText = methodItem.ReturnType.Name;
}
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_RETURN_GENERIC_RESPONSE, returnText);
if (xmlMethodObj != null && !string.IsNullOrEmpty(xmlMethodObj.Returns_WithSuccess))
{
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_SUCCESS_RESPONSE, xmlMethodObj.Returns_WithSuccess);
}
else
{
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_SUCCESS_RESPONSE, TemplateConsts.TEXT_NONE);
}
if (xmlMethodObj != null && !string.IsNullOrEmpty(xmlMethodObj.Returns_WithFail))
{
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_FAIL_RESPONSE, xmlMethodObj.Returns_WithFail);
}
else
{
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_FAIL_RESPONSE, TemplateConsts.TEXT_NONE);
}
}
private void SetTemplateData_Example(ApiMethodObj methodItem, MethodXmlElement xmlMethodObj, ref StringBuilder sbr_mdFileForMethod)
{
if (xmlMethodObj != null && !string.IsNullOrEmpty(xmlMethodObj.Example))
{
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_EXAMPLE, xmlMethodObj.Example);
}
else
{
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_EXAMPLE, TemplateConsts.TEXT_NONE);
}
}
private void SetTemplateData_MethodParameters(ApiMethodObj methodItem, MethodXmlElement xmlMethodObj, ref StringBuilder sbr_mdFileForMethod)
{
StringBuilder sbr_RequiredParams = new StringBuilder();
StringBuilder sbr_OptionalParams = new StringBuilder();
string fromBodyParam = TemplateConsts.TEXT_NONE;
foreach (var paramItem in methodItem.ParameterArray)
{
string paramDesc = xmlMethodObj?.ParamList.FirstOrDefault(t => t.Name == paramItem.ParamName)?.Value ?? "";
string appendingString = $"* **{paramItem.ParamName}** [{paramItem.GetCorrectedParamTypeName()}]";
if (paramItem.IsFromBody)
{
StringBuilder sbr_FromBody = new StringBuilder();
sbr_FromBody.AppendLine(appendingString);
sbr_FromBody.AppendLine(PADDING_PARAM + paramDesc);
sbr_FromBody.AppendLine();
fromBodyParam = sbr_FromBody.ToString();
if (xmlMethodObj != null)
{
xmlMethodObj.DataParamFromBody = fromBodyParam;
}
}
else
{
var refSbr = (paramItem.IsOptional) ? sbr_OptionalParams : sbr_RequiredParams;
refSbr.AppendLine(appendingString);
refSbr.AppendLine(PADDING_PARAM + paramDesc);
refSbr.AppendLine();
}
}
if (sbr_OptionalParams.Length == 0)
{
sbr_OptionalParams.AppendLine(CONST_NotApplicable);
}
if (sbr_RequiredParams.Length == 0)
{
sbr_RequiredParams.AppendLine(CONST_NotApplicable);
}
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_PARAM_LIST_REQUIRED, sbr_RequiredParams.ToString());
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_PARAM_LIST_OPTIONAL, sbr_OptionalParams.ToString());
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_PARAM_FROM_BODY, fromBodyParam);
}
private void HandleXml_Returns(XmlElement ele, ref MethodXmlElement memDef)
{
StringBuilder sbrReturn = new StringBuilder();
StringBuilder sbr_failed = new StringBuilder();
StringBuilder sbr_success = new StringBuilder();
List <XmlNode> childNodeList = ele.ChildNodes.Cast <XmlNode>().ToList();
if (childNodeList.Any(t => t.NodeType == XmlNodeType.Element && t.Name == "para" &&
t.InnerText.IsEqualToAny(StringComparison.InvariantCultureIgnoreCase, "fail", "failed", "fails", "success", "succeed")
)
)
{
//Means there is a clear division of success and failed
for (int i = 0; i < childNodeList.Count; i++)
{
XmlNode xmlNode = childNodeList[i];
if (xmlNode.NodeType == XmlNodeType.Element && xmlNode.Name == "para")
{
if (xmlNode.InnerText.IsEqualToAny(StringComparison.InvariantCultureIgnoreCase, "fail", "failed", "fails"))
{
//keep reading subsequent nodes till not end OR success OR another Fail is encountered
ProcessElement_Till_SuccessOrFailOrEnd(childNodeList, ref i, ref sbr_failed, 1);
}
else if (xmlNode.InnerText.IsEqualToAny(StringComparison.InvariantCultureIgnoreCase, "success", "succeed"))
{
//keep reading subsequent nodes till not end OR success OR another Fail is encountered
ProcessElement_Till_SuccessOrFailOrEnd(childNodeList, ref i, ref sbr_success, 1);
}
else
{
ProcessInnerElement(xmlNode, ref sbrReturn, 0);
}
}
else
{
ProcessInnerElement(xmlNode, ref sbrReturn, 0);
}
}
}
else
{
//means consider as simple return statement
ProcessInnerElement(ele, ref sbrReturn, 1);
}
memDef.Returns = sbrReturn.ToString();
memDef.Returns_WithFail = sbr_failed.ToString();
memDef.Returns_WithSuccess = sbr_success.ToString();
}
private void Process_ApiMethodObj(ApiControllerObj controllerItem, XmlCommentHelper xmlCommentHelper, string dateTimeString, string subControllerFolderPath, string subControllerFolderPath_Old)
{
foreach (ApiMethodObj methodItem in controllerItem.MethodArray)
{
string methodTypes = GetMethodType(methodItem.SupportedHttpMethodArray);
bool hasPostApi = methodTypes.Contains("POST");
StringBuilder sbr_mdFileForMethod = BasicApiTemplate.GetTemplateStringBuilder(hasPostApi, false, dateTimeString, this.VersionInfo, this.ImagePath);
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_API_NAME, methodItem.MethodName);
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_CONTROLLER_NAME, methodItem.ControllerName);
MethodXmlElement xmlMethodObj = null;
if (xmlCommentHelper != null)
{
xmlMethodObj = xmlCommentHelper.GetMemberDefinition(methodItem);
}
if (xmlMethodObj == null || string.IsNullOrWhiteSpace(xmlMethodObj.Summary) ||
(string.IsNullOrWhiteSpace(xmlMethodObj.Returns) && string.IsNullOrWhiteSpace(xmlMethodObj.Returns_WithSuccess) && string.IsNullOrWhiteSpace(xmlMethodObj.Returns_WithFail))
)
{
methodItem.IsCommentingMissing = true;
}
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_ADDITIONAL_INFO, xmlMethodObj?.Summary);
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_URL, $"/api/{ methodItem.ControllerName.Replace("Controller", "")}/{methodItem.MethodName}");
sbr_mdFileForMethod.Replace(TemplateConsts.PLACEHOLDER_METHOD_TYPE, methodTypes);
this.SetTemplateData_MethodParameters(methodItem, xmlMethodObj, ref sbr_mdFileForMethod);
this.SetTemplateData_Example(methodItem, xmlMethodObj, ref sbr_mdFileForMethod);
this.SetTemplateData_ReturnType(methodItem, xmlMethodObj, ref sbr_mdFileForMethod);
string fileNameOnly = this.GetValidFileName(methodItem.MethodName);
string fullMdFileAndPath = "";
methodItem.MDFileNameWithoutExtension = this.CreateMD_File_UsingOldNotes_IfApplicable(fileNameOnly, subControllerFolderPath, subControllerFolderPath_Old, sbr_mdFileForMethod, out fullMdFileAndPath);
MdToHtml.GenerateHtmlFile(fullMdFileAndPath);
}
}
public MethodXmlElement GetMemberDefinition(ApiMethodObj methodObj)
{
string parametersSignature = "(";
foreach (var p in methodObj.ParameterArray)
{
parametersSignature += p.ParamTypeName + ",";
}
if (methodObj.ParameterArray.Count > 0)
{
parametersSignature = parametersSignature.Remove(parametersSignature.Length - 1, 1);
}
parametersSignature += ")";
if (methodObj.ParameterArray.Count == 0)
{
parametersSignature = "";
}
var keyToLookfor = string.Format("M:{0}{1}", methodObj.FullMethodName, parametersSignature);
if (!MemberXmlElementLookup.ContainsKey(keyToLookfor))
{
return(null);
}
XmlElement ele = MemberXmlElementLookup[keyToLookfor];
MethodXmlElement memDef = new MethodXmlElement()
{
Name = methodObj.MethodName,
SourceXmlElement = ele
};
foreach (var c in ele.ChildNodes.Cast <XmlElement>())
{
try
{
if (c.Name == "summary")
{
memDef.Summary = this.GetXml_Summary(c);
}
else if (c.Name == "example")
{
memDef.Example = this.HandleXml_Example(c);
}
else if (c.Name == "returns")
{
this.HandleXml_Returns(c, ref memDef);
}
else if (c.Name == "param")
{
memDef.ParamList.Add(this.GetXml_Param(c));
}
}
catch (Exception ex)
{
Console.Write(ex);
}
}
if (string.IsNullOrWhiteSpace(memDef.Summary))
{
memDef.Summary = "No information found.";
}
if (string.IsNullOrWhiteSpace(memDef.DataParamFromBody))
{
memDef.DataParamFromBody = "N/A";
}
return(memDef);
}
