protected void Page_Load(object sender, EventArgs e) { // Registration to chat webservice AbstractCMSPage cmsPage = Page as AbstractCMSPage; if (cmsPage != null) { ChatScriptHelper.RegisterChatAJAXProxy(cmsPage); } // Script references insertion ChatScriptHelper.RegisterChatManager(Page); ScriptHelper.RegisterJQueryUI(Page); ScriptHelper.RegisterScriptFile(Page, "jquery/jquery-a-tools.js"); ScriptHelper.RegisterScriptFile(Page, "~/CMSModules/Chat/CMSPages/Scripts/BBCodeParser.js"); ScriptHelper.RegisterScriptFile(Page, "~/CMSWebParts/Chat/ChatMessageSend_files/ChatMessageSend.js"); imgInformationDialog.ImageUrl = GetImageUrl("General/Labels/Information.png"); RoomID = ChatUIHelper.GetRoomIdFromQuery(RoomID, GroupID); // Register startup script ScriptHelper.RegisterStartupScript(Page, typeof(string), "ChatMessageSend_" + ClientID, BuildStartupScript(), true); // Set link to documentation and tooltip for canned responses lnkCannedRespHelp.NavigateUrl = DocumentationHelper.GetDocumentationTopicUrl(CANNED_RESPONSES_HELP_TOPIC); lnkCannedRespHelp.ToolTip = ResHelper.GetString("chat.cannedresponses.helplabel"); }
/// <summary> /// Asserts the exported types with missing comments. /// </summary> /// <param name="assembly">The assembly.</param> /// <param name="excludeTypes">The exclude types.</param> public static void AssertExportedTypesWithMissingComments( Assembly assembly, List <Type>?excludeTypes = null) { if (assembly == null) { throw new ArgumentNullException(nameof(assembly)); } // Due to some build issue with GenerateDocumentationFile=true and xml-file location, this hack is made for now. if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { return; } var typesWithMissingCommentsGroups = DocumentationHelper.CollectExportedTypesWithMissingCommentsFromAssembly( assembly, excludeTypes) .OrderBy(x => x.Type.FullName) .GroupBy(x => x.Type.BeautifyName(true), StringComparer.Ordinal) .ToArray(); var testResults = new List <TestResult> { new TestResult($"Assembly: {assembly.GetName()}"), }; testResults.AddRange(typesWithMissingCommentsGroups.Select(item => new TestResult(false, 1, $"Type: {item.Key}"))); TestResultHelper.AssertOnTestResults(testResults); }
protected void Page_Load(object sender, EventArgs e) { product = SKUInfoProvider.GetSKUInfo(ProductID); // Setup help object options = new { helpName = "lnkProductEditHelp", helpUrl = DocumentationHelper.GetDocumentationTopicUrl(HELP_TOPIC_LINK) }; ScriptHelper.RegisterModule(this, "CMS/DialogContextHelpChange", options); EditedObject = product; if (product != null) { // Check site id CheckEditedObjectSiteID(product.SKUSiteID); // Load product currency productCurrency = CurrencyInfoProvider.GetMainCurrency(product.SKUSiteID); // Display product price headProductPriceInfo.Text = string.Format(GetString("com_sku_volume_discount.skupricelabel"), CurrencyInfoProvider.GetFormattedPrice(product.SKUPrice, productCurrency)); } // Set unigrid properties SetUnigridProperties(); // Initialize the master page elements InitializeMasterPage(); }
/// <summary> /// Asserts the exported types with missing comments. /// </summary> /// <param name="assembly">The assembly.</param> /// <param name="excludeTypes">The exclude types.</param> public static void AssertExportedTypesWithMissingComments( Assembly assembly, List <Type>?excludeTypes = null) { if (assembly == null) { throw new ArgumentNullException(nameof(assembly)); } var typesWithMissingCommentsGroups = DocumentationHelper.CollectExportedTypesWithMissingCommentsFromAssembly( assembly, excludeTypes) .OrderBy(x => x.Type.FullName) .GroupBy(x => x.Type.BeautifyName(true)) .ToArray(); var testResults = new List <TestResult> { new TestResult($"Assembly: {assembly.GetName()}"), }; testResults.AddRange(typesWithMissingCommentsGroups.Select(item => new TestResult(false, 1, $"Type: {item.Key}"))); TestResultHelper.AssertOnTestResults(testResults); }
public ReportingManager(IWebHostEnvironment webHostEnvironment) { this._webHostEnvironment = webHostEnvironment; var filePath = Path.Combine(webHostEnvironment.WebRootPath, "Source/TimeLog.TLP.WebAppCode.xml"); _helper = new DocumentationHelper(filePath); }
protected void Page_Load(object sender, EventArgs e) { var documentationLink = DocumentationHelper.GetDocumentationTopicUrl(CONVERSIONS_LOGGING_LINK); tipConversionsListing.CollapsedStateIdentifier = SMART_TIP_IDENTIFIER; tipConversionsListing.Content = string.Format(GetString("conversions.listingsmarttip"), documentationLink); tipConversionsListing.ExpandedHeader = GetString("conversions.listingsmarttip.header"); }
public string Serialize(Contract contract, string template, List <Contract> contracts) { string contractName = contract.ContractName; var contractNode = NodeHelper.GetContractNode(contract); string documentation = contractNode.Documentation; string contractTitle = DocumentationHelper.Get(documentation, "title"); string notice = DocumentationHelper.GetNotice(documentation); var anchors = contracts.Select(item => $"- [{item.ContractName}]({item.ContractName}.md)").ToList(); var dependencies = NodeHelper.GetBaseContracts(contract) ?? new List <Node>(); var implementations = NodeHelper.GetImplementations(contract, contracts) ?? new List <Contract>(); var dependencyList = dependencies.Select(dependency => $"[{dependency.BaseName.Name}]({dependency.BaseName.Name}.md)").ToList(); var implementationList = implementations.Select(implementation => $"[{implementation.ContractName}]({implementation.ContractName}.md)").ToList(); string title = $"{contract.ContractName}.sol"; if (!string.IsNullOrWhiteSpace(contractTitle)) { title = $"{Regex.Replace(contractTitle, @"\r\n?|\n", " ")} ({contract.ContractName}.sol)"; } string contractInheritancePath = string.Empty; string contractImplementations = string.Empty; if (dependencyList.Any()) { contractInheritancePath = $"**{string.Format(I18N.Extends, string.Join(", ", dependencyList))}**"; } if (implementationList.Any()) { contractImplementations = string.Join("", "**", string.Format(I18N.DerivedContracts, string.Join(", ", implementationList)), "**."); } template = template.Replace("{{ContractName}}", contractName); template = template.Replace("{{ContractTitle}}", title); template = template.Replace("{{ContractDescription}}", notice); template = template.Replace("{{ContractInheritancePath}}", contractInheritancePath); template = template.Replace("{{ContractImplementations}}", contractImplementations); template = template.Replace("{{AllContractsAnchor}}", string.Join(Environment.NewLine, anchors)); template = template.Replace("{{ABI}}", JsonConvert.SerializeObject(contract.Abi, Formatting.Indented)); var builder = new ConstructorBuilder(contract); return(builder.Build(template)); }
protected void Page_Load(object sender, EventArgs e) { // Setup help object options = new { helpName = "lnkProductEditHelp", helpUrl = DocumentationHelper.GetDocumentationTopicUrl(HELP_TOPIC_LINK) }; ScriptHelper.RegisterModule(this, "CMS/DialogContextHelpChange", options); // Check UI personalization for product / product option separately if (OptionCategoryID > 0) { // Check elements in product options categories subtree CheckUIElementAccessHierarchical(ModuleName.ECOMMERCE, "ProductOptions.Options.TaxClasses"); } else { CheckUIElementAccessHierarchical(ModuleName.ECOMMERCE, "Products.TaxClasses"); } if (ProductID > 0) { sku = SKUInfoProvider.GetSKUInfo(ProductID); EditedObject = sku; if (sku != null) { // Check products site id CheckEditedObjectSiteID(sku.SKUSiteID); taxForm.ProductID = ProductID; taxForm.UniSelector.OnSelectionChanged += UniSelector_OnSelectionChanged; if (sku.IsProductOption) { var categoryInfo = OptionCategoryInfoProvider.GetOptionCategoryInfo(sku.SKUOptionCategoryID); if (categoryInfo != null) { CreateBreadcrumbs(sku); if (categoryInfo.CategoryType != OptionCategoryTypeEnum.Products) { ShowError(GetString("com.taxesNotSupportedForOptionType")); taxForm.Visible = false; } } } } } }
/// <summary> /// Asserts the exported type with missing comments. /// </summary> /// <param name="type">The type.</param> public static void AssertExportedTypeWithMissingComments(Type type) { var typeComments = DocumentationHelper.CollectExportedTypeWithCommentsFromType(type); var testResults = new List <TestResult>(); if (typeComments != null && !typeComments.HasComments) { testResults.Add(new TestResult(true, 0, $"Type: {typeComments.Type.BeautifyTypeName(true)}")); } TestResultHelper.AssertOnTestResults(testResults); }
protected void Page_Load(object sender, EventArgs e) { if (Product != null) { CheckEditedObjectSiteID(Product.SKUSiteID); } if (!RequestHelper.IsPostBack()) { // Show confirmation message after generation of variants on generation page was successful if (QueryHelper.GetBoolean("saved", false)) { ShowConfirmation(GetString("com.variants.generated")); } } // Setup help object options = new { helpName = "lnkProductEditHelp", helpUrl = DocumentationHelper.GetDocumentationTopicUrl(HELP_TOPIC_LINK) }; ScriptHelper.RegisterModule(this, "CMS/DialogContextHelpChange", options); // Setup asynchronous control SetupControl(); // Init action selection InitBulkActionDropdownLists(); string warningMessage = VariantsCanBeGenerated(); if (string.IsNullOrEmpty(warningMessage)) { string url = "~/CMSModules/Ecommerce/Pages/Tools/Products/Variant_New.aspx"; url = URLHelper.AddParameterToUrl(url, "ProductID", ProductID.ToString()); url = URLHelper.AddParameterToUrl(url, "dialog", QueryHelper.GetString("dialog", "0")); // Allow user to generate variants CurrentMaster.HeaderActions.ActionsList.Add(new HeaderAction { Text = GetString("com.products.newvariant"), RedirectUrl = ResolveUrl(url) }); } else { ShowWarning(warningMessage); } }
public string Build(string template) { var node = NodeHelper.GetConstructorNode(this.Contract); string documentation = node.Documentation; string description = DocumentationHelper.GetNotice(documentation); var parameters = new List <string>(); var argBuilder = new StringBuilder(); var code = new StringBuilder(); var arguments = node.Modifiers?.FirstOrDefault()?.Arguments; code.Append("```js"); code.Append(Environment.NewLine); code.Append("constructor("); if (arguments == null) { return(Clean(template)); } foreach (var argument in arguments) { string argumentName = argument.Name; string dataType = argument.TypeDescriptions.TypeString.Replace("contract ", ""); string argumentDocumentation = DocumentationHelper.Get(documentation, "param " + argumentName); parameters.Add(dataType + " " + argumentName); argBuilder.Append($"| {argumentName} | {dataType} | {Regex.Replace(argumentDocumentation, @"\r\n?|\n", " ")} | {Environment.NewLine}"); } code.Append(string.Join(", ", parameters)); code.Append(") "); code.Append(node.Visibility.ToString().ToLower()); code.Append(Environment.NewLine); code.Append("```"); template = template.Replace("{{ConstructorHeading}}", $"## {I18N.Constructor}"); template = template.Replace("{{ConstructorDescription}}", description); template = template.Replace("{{ConstructorCode}}", code.ToString()); template = template.Replace("{{ConstructorArguments}}", argBuilder.ToString()); template = template.Replace("{{ConstructorArgumentsHeading}}", $"**{I18N.Arguments}**"); template = template.Replace("{{TableHeader}}", TemplateHelper.TableHeader); return(template); }
/// <summary> /// Page load event handling. /// </summary> protected void Page_Load(object sender, EventArgs e) { InitializeVersion(); ScriptHelper.RegisterModule(Page, "CMS/ContextHelp", new { wrapperId = ClientID, toolbarId = pnlToolbar.ClientID, helpTopicsMenuItemId = helpTopics.ClientID, searchMenuItemId = search.ClientID, searchUrlPattern = DocumentationHelper.GetDocumentationSearchUrlPattern(), descriptionMenuItemId = description.ClientID }); }
/// <summary>Analyzes a <see cref="SyntaxNode" />.</summary> /// <param name="context">The context for the syntax node analysis.</param> /// <param name="identifiers">Diagnostics will be reported for all provided identifiers, if the syntax node does not has a documentation header.</param> private void Analyze(SyntaxNodeAnalysisContext context, IEnumerable <SyntaxToken> identifiers) { Diagnostic diagnostic; if (!DocumentationHelper.HasDocumentationHeader(context.Node)) { foreach (SyntaxToken identifier in identifiers) { diagnostic = this.CreateDiagnostic(identifier.GetLocation(), identifier); context.ReportDiagnostic(diagnostic); } } }
private object PreparePromotingCampaignsSmartTip() { var documentationLink = DocumentationHelper.GetDocumentationTopicUrl(HELP_TOPIC_TRACKING_CAMPAIGNS_LINK); var smartTipContent = String.Format(GetString("campaigns.promotionsmarttip"), documentationLink); return(new { Identifier = SMART_TIP_PROMOTION_IDENTIFIER, Content = smartTipContent, ExpandedHeader = GetString("campaigns.promotionsmarttip.header"), CollapsedHeader = GetString("campaigns.promotionsmarttip.header"), IsCollapsed = mSmartTipManager.IsSmartTipDismissed(SMART_TIP_PROMOTION_IDENTIFIER) }); }
protected void Page_Load(object sender, EventArgs e) { // Setup help object options = new { helpName = "lnkProductEditHelp", helpUrl = DocumentationHelper.GetDocumentationTopicUrl(HELP_TOPIC_LINK) }; ScriptHelper.RegisterModule(this, "CMS/DialogContextHelpChange", options); if (ProductID > 0) { sku = SKUInfoProvider.GetSKUInfo(ProductID); EditedObject = sku; if (sku != null) { // Check site ID CheckEditedObjectSiteID(sku.SKUSiteID); ucOptions.ProductID = ProductID; // Add new category button in HeaderAction CurrentMaster.HeaderActions.ActionsList.Add(new HeaderAction { Text = GetString("com.productoptions.general.select"), OnClientClick = ucOptions.GetAddCategoryJavaScript(), Enabled = ECommerceContext.IsUserAuthorizedToModifySKU(sku.IsGlobal) }); // New button is active in editing of global product only if global option categories are allowed and user has GlobalModifyPermission permission bool enabledButton = (sku.IsGlobal) ? ECommerceSettings.AllowGlobalProductOptions(CurrentSiteName) && ECommerceContext.IsUserAuthorizedToModifyOptionCategory(true) : ECommerceContext.IsUserAuthorizedToModifyOptionCategory(false); // Create new enabled/disabled category button in HeaderAction var dialogUrl = UrlResolver.ResolveUrl("~/CMSModules/Ecommerce/Pages/Tools/ProductOptions/OptionCategory_New.aspx?ProductID=" + sku.SKUID + "&dialog=1"); dialogUrl = ApplicationUrlHelper.AppendDialogHash(dialogUrl); CurrentMaster.HeaderActions.ActionsList.Add(new HeaderAction { Text = GetString("com.productoptions.new"), Enabled = enabledButton, ButtonStyle = ButtonStyle.Default, OnClientClick = "modalDialog('" + dialogUrl + "','NewOptionCategoryDialog', 1000, 800);" }); } } }
public void OpenDocumentationForScene() { if (Application.isEditor) { var sceneName = SceneManager.GetActiveScene().name; if (sceneName.EndsWith("_cloud") || sceneName.EndsWith("_offline")) { sceneName = sceneName.Replace("_cloud", ""); sceneName = sceneName.Replace("_offline", ""); } DocumentationHelper.OpenDocumentationInBrowser(string.Format("scene_{0}.html", sceneName)); } }
/// <summary> /// Page_Load event handler. /// </summary> protected void Page_Load(object sender, EventArgs e) { // Get original value oldClassName = DocumentType.ClassName; oldInheritedID = DocumentType.ClassInheritsFromClassID; oldResourceID = DocumentType.ClassResourceID; var link = String.Format("<a target=\"_blank\" href=\"{0}\">{1}</a>", DocumentationHelper.GetDocumentationTopicUrl("routing_overview"), GetString("general.ourdocumentation")); tipUrlPattern.Content = string.Format(GetString("documenttype.urlpattern.smarttip.content"), link); tipUrlPattern.Visible = DocumentType.ClassHasURL; // Bind events editElem.OnAfterSave += editElem_OnAfterSave; }
public async Task <IActionResult> ExportEManifest(Guid hblid) { var accessToken = Request.Headers["Authorization"].ToString(); var responseFromApi = await HttpServiceExtension.GetApi(aPis.HostStaging + Urls.Documentation.HouseBillDetailUrl + hblid, accessToken); var dataObject = responseFromApi.Content.ReadAsAsync <CsTransactionDetailModel>(); var stream = new DocumentationHelper().CreateEManifestExcelFile(dataObject.Result); if (stream == null) { return(null); } FileContentResult fileContent = new FileHelper().ExportExcel(stream, "E-Manifest.xlsx"); return(fileContent); }
public string Serialize(Contract contract, string template, List <Contract> contracts) { var functionNodes = NodeHelper.GetFunctions(contract).Where(x => !x.IsConstructor.HasValue || !x.IsConstructor.Value).ToList(); if (!functionNodes.Any()) { return(Clean(template)); } var definitionList = new List <string>(); var functionList = functionNodes.Select(node => $"- [{node.Name}](#{node.Name.ToLower()})").ToList(); template = template.Replace("{{FunctionTitle}}", $"## {I18N.Functions}"); foreach (var node in functionNodes) { string functionTemplate = TemplateHelper.Function; string documentation = node.Documentation; string description = DocumentationHelper.GetNotice(documentation); var codeBuilder = new FunctionCodeBuilder(node); var superBuilder = new SuperBuilder(node, contracts); var referenceBuilder = new FunctionReferenceBuilder(node, contracts); functionTemplate = functionTemplate.Replace("{{FunctionName}}", node.Name); functionTemplate = functionTemplate.Replace("{{FQFunctionName}}", $"{contract.ContractName}.{node.Name}"); functionTemplate = functionTemplate.Replace("{{FunctionNameHeading}}", $"### {node.Name}"); functionTemplate = functionTemplate.Replace("{{Super}}", superBuilder.Build()); functionTemplate = functionTemplate.Replace("{{References}}", referenceBuilder.Build()); functionTemplate = functionTemplate.Replace("{{FunctionDescription}}", description); functionTemplate = functionTemplate.Replace("{{FunctionCode}}", codeBuilder.Build()); var parameters = node.Parameters.Parameters.ToList(); var argumentBuilder = new ArgumentBuilder(node.Documentation, parameters); functionTemplate = functionTemplate.Replace("{{TableHeader}}", parameters.Any() ? TemplateHelper.TableHeader : string.Empty); functionTemplate = functionTemplate.Replace("{{FunctionArgumentsHeading}}", parameters.Any() ? $"**{I18N.Arguments}**" : string.Empty); functionTemplate = functionTemplate.Replace("{{FunctionArguments}}", argumentBuilder.Build()); definitionList.Add(functionTemplate); } template = template.Replace("{{FunctionList}}", string.Join(Environment.NewLine, functionList)); template = template.Replace("{{AllFunctions}}", string.Join(Environment.NewLine, definitionList)); return(template); }
/// <summary> /// Check whether all macros in macro rule are optimized. /// Shows warning when not. /// </summary> private void CheckMacros() { var macroCondition = RuleHelper.GetMacroConditionFromRule(Rule); if (string.IsNullOrEmpty(macroCondition)) { return; } var macroTree = CachedMacroRuleTrees.GetParsedTree(macroCondition); if ((macroTree == null) || !MacroRuleTreeAnalyzer.CanTreeBeTranslated(macroTree)) { var text = string.Format(ResHelper.GetString("om.macros.macro.slow"), DocumentationHelper.GetDocumentationTopicUrl("om_macro_performance")); ShowWarning(text); } }
/// <summary>Calculates the position, the caret should be set to, after the /// code fix was applied.</summary> /// <param name="changedSolution">The changed solution (code fix applied).</param> /// <param name="originalDocument">The original document (code fix not applied).</param> /// <param name="diagnostic">The diagnosted code fix.</param> /// <param name="cancellationToken">A cancellation token to cancel the calculation.</param> /// <returns>The position , the caret should be set to, after the code fix /// was applied. Null if the caret should not be moved.</returns> private static async Task <NavigationTarget> CalculateNavigationTarget(Solution changedSolution, Document originalDocument, Diagnostic diagnostic, CancellationToken cancellationToken) { MemberDeclarationSyntax originalDeclaration; MemberDeclarationSyntax changedDeclaration; SyntaxNode originalSyntaxRoot; SyntaxNode changedSyntaxRoot; Document changedDocument; int targetPosition; NavigationTarget result = null; // Get syntax root of the original document originalSyntaxRoot = await originalDocument.GetSyntaxRootAsync(cancellationToken) .ConfigureAwait(false); // Get the original declaration that was diagnosted originalDeclaration = originalSyntaxRoot.FindToken(diagnostic.Location.SourceSpan.Start) .Parent .AncestorsAndSelf() .OfType <MemberDeclarationSyntax>() .First(); // Get the changed document changedDocument = changedSolution.GetDocument(originalDocument.Id); // Get syntax root of the changed document changedSyntaxRoot = await changedDocument.GetSyntaxRootAsync(cancellationToken) .ConfigureAwait(false); // Find declaration in changed document changedDeclaration = changedSyntaxRoot.DescendantNodes() .OfType <MemberDeclarationSyntax>() .FirstOrDefault(newNode => SyntaxFactory.AreEquivalent(newNode, originalDeclaration)); // Get the target position in the the XML documentation header of the // changed declaration inside the changed document targetPosition = DocumentationHelper.GetPositionOfFirstEmptyDocumentationTag(changedDeclaration); // targetPosition is less than zero if no empty documentation tag was found. if (targetPosition > 0) { result = new NavigationTarget(changedDocument.Id, targetPosition); } return(result); }
public string Build() { var builder = new StringBuilder(); foreach (var parameter in this.Parameters) { builder.Append("| "); builder.Append(parameter.Name); builder.Append(" | "); builder.Append(parameter.TypeDescriptions.TypeString.Replace("contract ", "")); builder.Append(" | "); string doc = DocumentationHelper.Get(this.Documentation, "param " + parameter.Name); builder.Append(doc); builder.Append(" | "); builder.Append(Environment.NewLine); } return(builder.ToString()); }
public async Task <IActionResult> ExportHAWBAirExport(string hblid, string officeId) { var responseFromApi = await HttpServiceExtension.GetApi(aPis.HostStaging + Urls.Documentation.NeutralHawbExportUrl + "?housebillId=" + hblid + "&officeId=" + officeId); var dataObject = responseFromApi.Content.ReadAsAsync <AirwayBillExportResult>(); if (dataObject.Result == null) { return(new FileHelper().ExportExcel(new MemoryStream(), "")); } var stream = new DocumentationHelper().GenerateHAWBAirExportExcel(dataObject.Result); if (stream == null) { return(new FileHelper().ExportExcel(new MemoryStream(), "")); } FileContentResult fileContent = new FileHelper().ExportExcel(stream, "Air Export - NEUTRAL HAWB.xlsx"); return(fileContent); }
public async Task <IActionResult> ExportTCSAirExport(string jobId) { var responseFromApi = await HttpServiceExtension.GetApi(aPis.HostStaging + Urls.Documentation.AirwayBillExportUrl + jobId); var dataObject = responseFromApi.Content.ReadAsAsync <AirwayBillExportResult>(); if (dataObject.Result == null) { return(new FileHelper().ExportExcel(new MemoryStream(), "")); } var stream = new DocumentationHelper().GenerateTCSAirExportExcel(dataObject.Result); if (stream == null) { return(new FileHelper().ExportExcel(new MemoryStream(), "")); } FileContentResult fileContent = new FileHelper().ExportExcel(stream, "Air Export - Phiếu Cân TCS.xlsx"); return(fileContent); }
public async Task <IActionResult> ExportShipmentOverview(GeneralReportCriteria criteria) { var responseFromApi = await HttpServiceExtension.GetDataFromApi(criteria, aPis.HostStaging + Urls.Documentation.GetDataShipmentOverviewUrl); var dataObjects = responseFromApi.Content.ReadAsAsync <List <ExportShipmentOverview> >(); if (dataObjects.Result == null) { return(new FileHelper().ExportExcel(new MemoryStream(), "")); } var stream = new DocumentationHelper().GenerateShipmentOverviewExcel(dataObjects.Result, criteria, null); if (stream == null) { return(new FileHelper().ExportExcel(new MemoryStream(), "")); } FileContentResult fileContent = new FileHelper().ExportExcel(stream, "Shipment Overview.xlsx"); return(fileContent); }
/// <summary> /// Handles external data bound. /// Renders link to help page and enables/disables grid editing buttons. /// </summary> private object Control_OnExternalDataBound(object sender, string sourceName, object parameter) { switch (sourceName.ToLowerCSafe()) { case "helptopiclink": { string linkUrl = (string)parameter; linkUrl = DocumentationHelper.GetDocumentationTopicUrl(linkUrl); return(String.Format("<a href=\"{0}\" target=\"_blank\">{1}</a>", linkUrl, HTMLHelper.HTMLEncode(linkUrl))); } case "delete_modify": case "move_modify": CMSGridActionButton button = (CMSGridActionButton)sender; button.Enabled = EditingEnabled; break; } return(parameter); }
public string Serialize(Contract contract, string template, List <Contract> contracts) { var modifierNodes = NodeHelper.GetModifiers(contract).ToList(); if (!modifierNodes.Any()) { return(Clean(template)); } var definitionList = new List <string>(); var modifierList = modifierNodes.Select(node => $"- [{node.Name}](#{node.Name.ToLower()})").ToList(); template = template.Replace("{{ModifierTitle}}", $"## {I18N.Modifiers}"); foreach (var node in modifierNodes) { string modifierTemplate = TemplateHelper.Modifier; string documentation = node.Documentation; string description = DocumentationHelper.GetNotice(documentation); var argumentBuilder = new ArgumentBuilder(documentation, node.Parameters.Parameters); var codeBuilder = new ModifierCodeBuilder(node); modifierTemplate = modifierTemplate.Replace("{{ModifierArgumentsHeading}}", $"**{I18N.Arguments}**"); modifierTemplate = modifierTemplate.Replace("{{TableHeader}}", TemplateHelper.TableHeader); modifierTemplate = modifierTemplate.Replace("{{ModifierNameHeading}}", $"### {node.Name}"); modifierTemplate = modifierTemplate.Replace("{{ModifierDescription}}", description); modifierTemplate = modifierTemplate.Replace("{{ModifierCode}}", codeBuilder.Build()); modifierTemplate = modifierTemplate.Replace("{{ModifierArguments}}", argumentBuilder.Build()); definitionList.Add(modifierTemplate); } template = template.Replace("{{ModifierList}}", string.Join(Environment.NewLine, modifierList)); template = template.Replace("{{AllModifiers}}", string.Join(Environment.NewLine, definitionList)); return(template); }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); // Setup help object options = new { helpName = "lnkProductEditHelp", helpUrl = DocumentationHelper.GetDocumentationTopicUrl(HELP_TOPIC_LINK) }; ScriptHelper.RegisterModule(this, "CMS/DialogContextHelpChange", options); if (IsProductOption) { // Check UI personalization for product option CheckUIElementAccessHierarchical(ModuleName.ECOMMERCE, "ProductOptions.Options.General"); } else { // Check UI personalization for product CheckUIElementAccessHierarchical(ModuleName.ECOMMERCE, "Products.General"); } }
protected override void OnPreRender(EventArgs e) { base.OnPreRender(e); iconHelp.Attributes["class"] = IconName + " " + IconCssClass; iconHelp.Attributes["title"] = Tooltip; if (!String.IsNullOrEmpty(TopicName)) { lnkHelp.NavigateUrl = DocumentationHelper.GetDocumentationTopicUrl(TopicName); } // Render help name script if (!String.IsNullOrEmpty(HelpName)) { object options = new { helpName = HelpName, helpLinkId = lnkHelp.ClientID, helpHidden = String.IsNullOrEmpty(TopicName) }; ScriptHelper.RegisterModule(this, "CMS/DialogContextHelp", options); } }
/// <summary> /// Tests SharePoint connection using configuration currently filled in the form. /// </summary> private void TestConnection() { try { ISharePointSiteService siteService = SharePointServices.GetService <ISharePointSiteService>(GetConnectionData()); siteService.GetSiteUrl(); DisplayConnectionStatus(GetString("sharepoint.testconnection.success")); } catch (SharePointServiceFactoryNotSupportedException) { // No service factory for given SharePoint version DisplayConnectionStatus(GetString("sharepoint.versionnotsupported"), false); } catch (SharePointServiceNotSupportedException) { // No ISiteService implementation for SharePoint version DisplayConnectionStatus(GetString("sharepoint.testconnectionnotsupported"), false); } catch (SharePointConnectionNotSupportedException) { // The ISiteService implementation rejected connection data DisplayConnectionStatus(GetString("sharepoint.invalidconfiguration"), false); } catch (SharePointCCSDKException ex) { var message = string.Format(GetString("sharepoint.ccsdk.idcrl.msoidclilerror"), DocumentationHelper.GetDocumentationTopicUrl("sharepoint_online_connecting")); DisplayConnectionStatus(message, false, true); EventLogProvider.LogException("SharePoint", "TESTCONNECTION", ex); } catch (WebException ex) { if (ex.Status == WebExceptionStatus.ProtocolError) { // Connection established, but response indicates error condition if (ex.Message.Contains("401")) { // Unauthorized. DisplayConnectionStatus(GetString("sharepoint.protocolerror.unauthorized"), false); } else if (ex.Message.Contains("404")) { // SharePoint instance not found on given URL DisplayConnectionStatus(GetString("sharepoint.protocolerror.notfound"), false); } else { // Some other protocol error DisplayConnectionStatus(GetString("sharepoint.protocolerror"), false); } } else if (ex.Status == WebExceptionStatus.NameResolutionFailure) { // Given site URL does not have a resolution DisplayConnectionStatus(GetString("sharepoint.nameresolutionfailure"), false); } else { DisplayConnectionStatus(GetString("sharepoint.unknownerror"), false); EventLogProvider.LogException("SharePoint", "TESTCONNECTION", ex); } } catch (Exception ex) { DisplayConnectionStatus(GetString("sharepoint.unknownerror"), false); EventLogProvider.LogException("SharePoint", "TESTCONNECTION", ex); } }