ReportViewer-Hide PDF Export

j'ai eu exactement le même problème et résolu en utilisant la méthode C # suivante, trouvé ici!:

public void DisableUnwantedExportFormat(ReportViewer ReportViewerID, string strFormatName)
{
    FieldInfo info;

    foreach (RenderingExtension extension in ReportViewerID.LocalReport.ListRenderingExtensions())
     {
        if (extension.Name == strFormatName)
        {
             info = extension.GetType().GetField("m_isVisible", BindingFlags.Instance | BindingFlags.NonPublic);
            info.SetValue(extension, false);
        }
    }
}

DisableUnwantedExportFormat(ReportViewer1, "PDF");

ceci est la façon dont vous désactivez une option d'exportation, marquez juste tous ceux sauf Excel à false.

*N'oubliez pas de relancer le service de rapports.

fichier: InstallPath\Reporting Services\ReportServer\rsreportserver.config

Activé:

<Extension Name="EXCEL"
Type="Microsoft.ReportingServices.Rendering.ExcelRenderer.ExcelRenderer,Microsoft.ReportingServices.ExcelRendering"/>

Désactivé:

<Extension Name="EXCEL"
Type="Microsoft.ReportingServices.Rendering.ExcelRenderer.ExcelRenderer,Microsoft.ReportingServices.ExcelRendering"
Visible="false"/>

cette approche jQuery simple a fonctionné pour moi:

 $(document).ready(function () {
     $("a[title='PDF']").parent().hide();  // Remove from export dropdown.
     $("a[title='MHTML (web archive)']").parent().hide();  
     $("a[title='TIFF file']").parent().hide();  
 });

en utilisant le code jon ci-dessus comme référence, j'arrive à cacher "Excel" dans le programme à l'exécution. Cependant, je ne suis pas bon a VB.net donc j'ai mis un échantillon dans C#. Désolé à ce sujet mais j'espère que cette aide. Encore une chose, le rapport le intégré à l'intérieur d'un ASP.net page.

  // This is the Load event of the reports itself.
  // Call the recursive method.
  protected void ReportViewerResults_Load(object sender, EventArgs e)
  {
    CustomizeRV((System.Web.UI.Control)sender);
  }

  // Patterned from Jon.
  // Traverse all controls/child controls to get the dropdownlist.
  // The first dropdown list is the ZoomGroup, followed by the ExportGroup.
  // We just wanted the ExportGroup.
  // When a dropdownlist is found, create a event handler to be used upon rendering.
  private void CustomizeRV(System.Web.UI.Control reportControl)
  {
    foreach (System.Web.UI.Control childControl in reportControl.Controls)
    {
      if (childControl.GetType() == typeof(System.Web.UI.WebControls.DropDownList))
      {
        System.Web.UI.WebControls.DropDownList ddList = (System.Web.UI.WebControls.DropDownList)childControl;
        ddList.PreRender += new EventHandler(ddList_PreRender);
      }
      if (childControl.Controls.Count > 0)
      {
        CustomizeRV(childControl);
      }
    }
  }

  // This is the event handler added from CustomizeRV
  // We just check the object type to get what we needed.
  // Once the dropdownlist is found, we check if it is for the ExportGroup.
  // Meaning, the "Excel" text should exists.
  // Then, just traverse the list and disable the "Excel".
  // When the report is shown, "Excel" will no longer be on the list.
  // You can also do this to "PDF" or if you want to change the text.
  void ddList_PreRender(object sender, EventArgs e)
  {
    if (sender.GetType() == typeof(System.Web.UI.WebControls.DropDownList))
    {
      System.Web.UI.WebControls.DropDownList ddList = (System.Web.UI.WebControls.DropDownList)sender;
      System.Web.UI.WebControls.ListItemCollection listItems = ddList.Items;

      if ((listItems != null) && (listItems.Count > 0) && (listItems.FindByText("Excel") != null))
      {
        foreach (System.Web.UI.WebControls.ListItem list in listItems)
        {
          if (list.Text.Equals("Excel")) 
          {
            list.Enabled = false;
          }
        }
      }
    }
  }

j'essayais de sélectionner L'élément par défaut "PDF" mais je n'ai pas trouvé de moyen d'activer le bouton "Exporter" du texte. :-(

j'ai eu le même problème. Je pouvais obtenir les options d'exportation indésirables à cacher quand le rapport a rendu, mais il n'a pas fonctionné dans le cas d'un rapport drillthrough. Le code suivant a fonctionné pour les rapports parent et drillthrough, en utilisant un rapport Local:

    private void SuppressExportButton(ReportViewer rv, string optionToSuppress)
    {
        var reList = rv.LocalReport.ListRenderingExtensions();
        foreach (var re in reList)
        {
            if (re.Name.Trim().ToUpper() == optionToSuppress.Trim().ToUpper()) // Hide the option
            {
                re.GetType().GetField("m_isVisible", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(re, false);
            }
        }
    }

le truc est d'appeler la méthode à partir de la méthode PreRender page:

    protected void Page_PreRender(object sender, System.EventArgs e)
    {
        SuppressExportButton(rvMain, "PDF");
        SuppressExportButton(rvMain, "Word");
    }

j'ai réussi à désactiver le bouton D'exportation PDF avec quelques retouches. La classe ReportViewer n'a pas de fonctions face au public pour désactiver le bouton Exporter vers la barre D'outils PDF. Pour ce faire, regardez le code suivant:

appeler cette fonction pendant l'événement OnLoad de votre page reportViewer:

 Private Sub CustomizeRV(ByVal ctrl As Control)
    For Each c As Control In ctrl.Controls
      If TypeOf c Is ToolStrip Then
        Dim ts As ToolStrip = DirectCast(c, ToolStrip)
        For i As Integer = 0 To ts.Items.Count - 1
          If ts.Items(i).Name = "export" Then
            Dim exp As ToolStripDropDownButton = ts.Items(i)
            AddHandler exp.DropDownOpening, AddressOf disableButton
          End If
        Next
      End If
      If c.HasChildren Then
        CustomizeRV(c)
      End If
    Next
  End Sub

Je n'ai pas pu définir la propriété Visible du bouton toolstrip ici, puisque les options D'exportation sont chargées OnDropDownOpened. Au lieu de cela, j'ai ajouté un handler pour prendre soin de désactiver l'option d'exportation lorsque l'option ToolStrip Dropdown est cliquée. La fonction de gestionnaire est comme suit:

  Private Sub disableButton(ByVal sender As Object, ByVal e As System.EventArgs)
    Dim btn As ToolStripDropDownButton = DirectCast(sender, ToolStripDropDownButton)
    btn.DropDownItems(1).Visible = False
  End Sub

donc, en gros, Onload vous ajoutez un gestionnaire D'événements de sorte que lorsque le bouton Exporter vers le bas est cliqué, la fonction ci - dessus s'exécute-rendant l'exportation vers le PDF invisible.

la solution fonctionnera à coup sûr, je viens de finir de la faire fonctionner.

Si vous avez des questions, laissez-moi savoir.

public void DisableUnwantedExportFormats()
{
    FieldInfo info;

    foreach (RenderingExtension extension in reportViewer.ServerReport.ListRenderingExtensions())
    {
        if (extension.Name != "PDF" && extension.Name != "EXCEL") // only PDF and Excel - remove the other options
        {
            info = extension.GetType().GetField("m_isVisible", BindingFlags.Instance | BindingFlags.NonPublic);
            info.SetValue(extension, false);
        }

        if (extension.Name == "EXCEL") // change "Excel" name on the list to "Excel 97-2003 Workbook"
        {
            info = extension.GetType().GetField("m_localizedName", BindingFlags.Instance | BindingFlags.NonPublic);
            if (info != null) info.SetValue(extension, "Excel 97-2003 Workbook");
        }
    }
}

j'ai essayé en ajoutant ladite méthode DisableUnwantedExportFormats() pour cacher l'Exportation vers Excel option. Lorsque le rapport est chargé pour la première fois, L'option Excel ne devient pas visible.

Cependant, Lorsque j'ai utilisé pour faire appel à la même méthode à l'intérieur de Drillthrough() l'option "Excel" & PDF devient visible dans la liste déroulante des contrôles à l'exportation. J'ai essayé en appelant votre méthode dans la première déclaration de mon Drillthrough() événement (comme ce que j'ai utilisé dans la méthode de chargement de la Page).

s'il vous Plaît laissez-moi savoir, Comment puis-je cacher la excel option Drillthrough() événement de Reportviewer.

jQuery solution pour reportviewer 2010: Mettez ceci dans le fichier aspx contenant le contrôle reportviewer (en supposant que votre reportviewer s'appelle ReportViewer1)

<script type="text/javascript">
    $(document).ready(function () {
        hideExportOptions();
    });

    function hideExportOptions() {
        //Find the menu id by getting the parent of the parent of one of the export links
        var menuID = $("a[onclick=\"$find('ReportViewer1').exportReport('PDF');\"]").parent().parent().attr("id");
        if ($("#" + menuID).length > 0) {
            $("#" + menuID  + " div:nth-child(3)").css('display', 'none');
        }
        else {
            setTimeout("hideExportOptions()", 1000);
        }
    }

</script> 

il attend jusqu'à ce que le dropdown soit rendu, puis cache l'option choisie. Généralement, le setTimeout ne se produit qu'une seule fois. Vous pouvez cacher plus / d'autres en ajoutant plus de nth-childs, Le nombre étant la position 1-basée dans la liste déroulante de l'option que vous voulez cacher.

1. Mot De option référence à "WORDOPENXML"
2. to Excel option reference to "EXCELOPENXML"
3. PDF option référence à "PDF"

Cordialement.

Dans le code derrière, charger une valeur cachée lors de l'affichage du rapport

this.ReportServViewer.ServerReport.Refresh();
this.hidReportViewing.Value = "algo";

ensuite, utilisez le javascript suivant pour configurer une minuterie pour vérifier les boutons d'exportation à rendre. Quand ils sont rendus, enlever le bouton et effacer la minuterie.

<script>
 var intervalHandler;
 var maxTries = 10;
 var currentTries = 0;

 function removePDFFromReporting() {
            var clear = false;
            if (intervalHandler != null) {                 
                if ($('#hidReportViewing').val() != '') {                    
                    var anchor = $("#<%= ReportServViewer.ClientID%>_fixedTable  a:contains('PDF')");
                    if (anchor.length == 0) {
                        currentTries = currentTries + 1;
                        clear = currentTries >= maxTries;
                    }
                    else {
                        anchor.remove();
                        clear = true;                       
                    }
                }
            }

            if (clear) {
                $('#hidReportViewing').val('');
                clearInterval(intervalHandler);
                intervalHandler = null;
            }
        }

</script>

dans la charge d'ajouter (ie $(document).prêt())

if ($('#hidReportViewing').val() != '')
 {
               intervalHandler = setInterval(removePDFFromReporting, 1500);
 }

j'ai réussi à le faire du côté client en utilisant JavaScript au bas de la page.

var exportSelectBox = document.getElementById("ReportViewer1__ctl1__ctl5__ctl0");
exportSelectBox.remove(7);
exportSelectBox.remove(6);
exportSelectBox.remove(5);
exportSelectBox.remove(4);
exportSelectBox.remove(1);
exportSelectBox.remove(1);

si ça peut aider... le code pour cacher l'article excel em VB.Net (.Net 3.5)

Private Sub CustomizeRV(ByVal ctrl As ReportViewer)

    For Each c As Control In ctrl.Controls

        If c.GetType.ToString = "Microsoft.Reporting.WebForms.ToolbarControl" Then

            For Each ct In c.Controls

                If ct.GetType.ToString = "Microsoft.Reporting.WebForms.ExportGroup" Then

                    Dim cbo As DropDownList = CType(ct.controls(0), DropDownList)

                    AddHandler cbo.PreRender, AddressOf cboExportReportViewer_PreRender

                End If

            Next

        End If

    Next

End Sub

Protected Sub cboExportReportViewer_PreRender(ByVal sender As Object, ByVal e As System.EventArgs)

    Dim cbo = CType(sender, DropDownList)

    For i As Integer = 0 To cbo.Items.Count - 1

        If cbo.Items(i).Text.ToLower = "excel" Then
            cbo.Items.Remove(cbo.Items(i))
            Exit Sub
        End If

    Next

End Sub

... et mettre un appel à CustomizeRV(ReportViewer1) dans le page_load événement

Pour ReportViewer >2010-je utiliser cette approche fait avec jQuery

function HideExtension(ext) {
        var $reportViewer = $("[id*=ReportViewer1]");
        var $botons = $reportViewer.find("a");
        $botons.each(function (index,element) {
            if($(element).html()==ext)
            {
                $(element).parent().css("display", "none");
            }
        });
    }

il suffit de changer le sélecteur pour le vôtre et d'appeler la fonction de $(document).ready(function(){//here})

seulement après rafraîchissement, comme ceci:

ReportViewer1.LocalReport.Refresh ();

                string exportOption = "PDF";
                RenderingExtension extension = ReportViewer1.LocalReport.ListRenderingExtensions().ToList().Find(x => x.Name.Equals(exportOption, StringComparison.CurrentCultureIgnoreCase));
                if (extension != null)
                {
                    System.Reflection.FieldInfo fieldInfo = extension.GetType().GetField("m_isVisible", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
                    fieldInfo.SetValue(extension, false);
                }

le voir sur ce lien...

https://www.aspsnippets.com/Articles/ASPNet-RDLC-Local-SSRS-Report-Viewer-Hide-Disable-specific-export-option-Word-Excel-PDF-from-Export-button.aspx

si vous êtes intéressé par une solution javascript rapide utilisant jQuery ..

il suffit de remplacer le sélecteur reportViewer ci-dessous par votre ID de dépose.

jQuery ('#ctl00_ContentPlaceHolder1_rptViewer_ctl01_ctl05_ctl00').enfant.)(supprimer(); jQuery ("#ctl00_ContentPlaceHolder1_rptViewer_ctl01_ctl05_ctl00").annexe ("- choisir le format d'exportation -"); jQuery ("#ctl00_ContentPlaceHolder1_rptViewer_ctl01_ctl05_ctl00").annexe ("EXCEL");

cela supprime toutes les options et ajoute ensuite dans EXCEL comme seule option.

après 4 heures de recherches j'ai trouvé la solution. J'ai fait quelques petits changements marol du code pour être plus petit:

        Control ReportViewerControl = ReportViewer1.FindControl("Ctl01");
        Control ExportGroupControl = ReportViewerControl.FindControl("Ctl05");
        DropDownList DropDownControl = (DropDownList)ExportGroupControl.FindControl("Ctl00");
        DropDownControl.PreRender += new EventHandler(ddList_PreRender);

Inspiré par la réponse https://stackoverflow.com/a/9192978/1099519 j'ai créé deux méthodes d'extension.

dans mon cas, j'utilise une approche de liste blanche en n'activant que les formats que je veux (donc vous devez inclure ceux que vous voulez sauf PDF):

reportViewer.ServerReport.SetExportFormats("EXCELOPENXML", "EXCEL", "XML", "CSV");

les méthodes D'Extension ressemblent à ceci (supportant à la fois Server - et LocalReports):

/// <summary>
/// Extension for ReportViewer Control
/// </summary>
public static class ReportViewerExtensions
{
    private const string VisibleFieldName = "m_isVisible";
    /// <summary>
    /// Sets the supported formats on the <see cref="ServerReport"/>
    /// </summary>
    /// <param name="serverReport"><see cref="ServerReport"/> instance to set formats on</param>
    /// <param name="formatNames">Supported formats</param>
    public static void SetExportFormats(this ServerReport serverReport, params string[] formatNames)
    {
        SetExportFormats(serverReport.ListRenderingExtensions(), formatNames);
    }
    /// <summary>
    /// Sets the supported formats on the <see cref="LocalReport"/>
    /// </summary>
    /// <param name="localReport"><see cref="LocalReport"/> instance to set formats on </param>
    /// <param name="formatNames">Supported formats</param>
    public static void SetExportFormats(this LocalReport localReport, params string[] formatNames)
    {
        SetExportFormats(localReport.ListRenderingExtensions(), formatNames);
    }

    /// <summary>
    /// Setting the visibility on the <see cref="RenderingExtension"/>
    /// </summary>
    /// <param name="renderingExtensions">List of <see cref="RenderingExtension"/></param>
    /// <param name="formatNames">A list of Formats that should be visible (Case Sensitive)</param>
    private static void SetExportFormats(RenderingExtension[] renderingExtensions, string[] formatNames)
    {
        FieldInfo fieldInfo;
        foreach (RenderingExtension extension in renderingExtensions)
        {
            if (!formatNames.Contains(extension.Name))
            {
                fieldInfo = extension.GetType().GetField(VisibleFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
                fieldInfo.SetValue(extension, false);
            }

        }
    }
}