Ticomix.TelerikReporting

Purpose Statement

A .NET library that provides comprehensive Telerik Reporting integration for web applications, enabling report design, viewing, and management capabilities with support for both Angular and MVC frameworks. Built on Telerik Reporting 18.1.24.709 with enhanced features for enterprise reporting solutions.

Database Models Used

The package requires the following database models to be added to your application:

• ReportFile: Stores report definition files and metadata
• ReportFolder: Hierarchical organization of reports
• ReportHeader: Main report metadata and configuration
• ReportSubscriptionParameter: Parameter definitions for scheduled reports
• ReportSubscriptionTelerik: Telerik-specific subscription settings
• ReportSubscriptionRun: Execution history and status tracking
• ReportVersion: Version control for report definitions
• SysJobStatus: Background job status tracking
• ErrorLog: Comprehensive error logging and monitoring

Additional context files required:

• ApplicationDbContextErrorLog.cs
• ApplicationDbContextTelerikReporting.cs

Classes and Functions

Core Controllers

• TelerikReportDesignerController: Handles report designer web service requests
• TelerikReportViewerController: Manages report viewer functionality
• ReportDesignerController: Custom report designer operations
• ReportViewerController: Custom report viewing operations

Helper Classes

• ReportHelper: Utility functions for report operations and management

ViewModels

• ReportHeaderViewModel: Data transfer object for report metadata

Installation Instructions

Prerequisites

Ensure your application has the following NuGet packages installed:

• Ticomix.TelerikReporting
• Ticomix.AspNetCore.Mvc.Knedo
• Ticomix.AspNetCore.Web
• Ticomix.Common
• Ticomix.EFCore

Database Setup

1. Add the required database models and migrations to your project
2. Include the context files in your \Data folder
3. Run database migrations to create the necessary tables

ASP.NET Core Configuration

Startup.cs / Program.cs Changes

1. Configure Swagger (exclude Telerik controllers):

services.AddSwaggerGen(c =>
{
    c.DocInclusionPredicate((docName, apiDesc) =>
    {
        if (apiDesc.ActionDescriptor is ControllerActionDescriptor desc && 
            desc.ControllerTypeInfo.Assembly.FullName.StartsWith("Telerik"))
        {
            return false;
        }
        return apiDesc.GroupName == null || apiDesc.GroupName == docName;
    });
    c.SchemaFilter<NullableSchemaFilter>();
});

2. Configure Globalization:

Globals.SupportedCultures = CultureInfo.GetCultures(CultureTypes.SpecificCultures);
Globals.DefaultCulture = new CultureInfo("en-US");

3. Add User Roles:

UserRoleHelper.CreateUserRole("Telerik Report View", 
    Description: "Ability to view Telerik Reports");
UserRoleHelper.CreateUserRole("Telerik Report Edit", 
    Description: "Ability to create and edit Telerik Reports through the web report designer.");

4. Configure Services:

// Distributed Cache
services.AddDistributedSqlServerCache(options =>
{
    options.ConnectionString = Configuration.GetConnectionString("DefaultConnection");
    options.SchemaName = "dbo";
    options.TableName = "DistributedCacheTable";
});

// Session Management
services.AddSession();

// Distributed Locking
services.AddSingleton<IDistributedLockProvider>((services) => 
    new SqlDistributedSynchronizationProvider(Configuration.GetConnectionString("DefaultConnection")));

// Logging
services.AddScoped<ILogger, Ticomix.Common.Helpers.Logger<int>>();
services.AddScoped<Microsoft.Extensions.Logging.ILogger>((sp) => sp.GetRequiredService<ILogger>());

// Cancellation Token
services.AddScoped(typeof(CancellationToken), serviceProvider =>
{
    IHttpContextAccessor httpContext = serviceProvider.GetRequiredService<IHttpContextAccessor>();
    return httpContext.HttpContext?.RequestAborted ?? CancellationToken.None;
});

// Telerik Reporting Configuration
services.Configure<Ticomix.TelerikReporting.TelerikReportingOptions>(options =>
{
    Configuration.Bind("TelerikReporting", options);
});
services.AddTelerikReporting<int>();

5. Configure JSON Serialization:

services.AddControllers(c =>
{
    c.Conventions.Add(new ApiExplorerGroupPerVersionConvention());
}).AddJsonOptions(options =>
{
    options.JsonSerializerOptions.PropertyNamingPolicy = null;
}).AddNewtonsoftJson(options =>
{
    options.SerializerSettings.ContractResolver = new DefaultContractResolver();
});

6. Configure Middleware:

app.UseSession();

wwwroot Setup

1. Create a wwwroot folder in your server project root
2. Create a Reports subfolder
3. Copy Blank Report.trdp into the Reports folder for new report creation

Controller Implementation Examples

Report Management Controller

Example implementation for managing report definitions and metadata:

[Route("api/[controller]/[action]")]
[ApiController]
[Authorize(Roles = "Telerik Report Edit")]
public class ReportDesignerController : ControllerBase
{
    private readonly ApplicationDbContext db;
    private readonly ReportHelper ReportHelper;
    private readonly UserRoleHelper userRoleHelper;

    public ReportDesignerController(IWebHostEnvironment environment, IHttpContextAccessor accessor, 
        ApplicationDbContext context, IOptionsSnapshot<AppConfiguration> appConfiguration)
    {
        db = context;
        db.SetUserName(accessor.HttpContext?.User?.Identity?.Name);
        ReportHelper = new ReportHelper(db, environment);
        userRoleHelper = new UserRoleHelper(db, appConfiguration.Value.SiteId);
    }

    [HttpPost]
    [ProducesResponseType(200, Type = typeof(IDataSourceResult<ReportHeaderViewModel>))]
    public async Task<ActionResult> List_KendoGrid([FromBody] WebApiDataSourceRequest<ReportHeaderViewModel> request, CancellationToken cancellationToken)
    {
        var data = (from rh in db.ReportHeader.AsNoTracking()
                    join rv in db.ReportVersion.AsNoTracking() on rh.IDReportHeader equals rv.ReportHeaderID
                    where rh.Deleted == false
                    select new ReportHeaderViewModel
                    {
                        IDReportHeader = rh.IDReportHeader,
                        FileName = rh.FileName,
                        Description = rh.Description,
                        LastEditedUser = rv.AddUser,
                        LastEditedDateTime = rv.AddDate,
                        IncludeInReportIndex = rh.IncludeInReportIndex,
                        Version = rv.Version
                    }).ToList();

        var result = await data.ToDataSourceResultAsync(request.ToDataSourceRequest(), cancellationToken);
        return Ok(result);
    }

    [HttpPost]
    [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(ReportHeader))]
    public async Task<IActionResult> PostReportHeader([FromBody] ReportHeader viewmodel)
    {
        if (viewmodel.IDReportHeader == Guid.Empty)
        {
            // Create new report with role-based security
            string reportName = Path.GetFileNameWithoutExtension(viewmodel.FileName);
            userRoleHelper.CreateTelerikReportRole(reportName);
            
            string? adminId = userRoleHelper.GetGroupId("Administrator");
            if (adminId != null)
            {
                userRoleHelper.AssignAdministratorRoles(adminId);
            }
        }
        
        return Ok(viewmodel);
    }
}

Report Viewer Controller

Example implementation for viewing reports with role-based access:

[Route("api/[controller]/[action]")]
[ApiController]
[Authorize(Roles = "Telerik Report View")]
public class ReportViewerController : ControllerBase
{
    [HttpPost]
    [ProducesResponseType(200, Type = typeof(IDataSourceResult<ReportListItem>))]
    public async Task<ActionResult> List_KendoGrid([FromBody] WebApiDataSourceRequest<ReportListItem> request, CancellationToken cancellationToken)
    {
        // Get allowed reports based on user roles
        var allowedReports = User.Claims
            .Where(c => c.Type == ClaimTypes.Role && c.Value.StartsWith(TelerikReportLogic.RolePrefix))
            .Select(c => c.Value.Substring(TelerikReportLogic.RolePrefix.Length))
            .ToList();

        var data = await ReportHelper.GetReports(cancellationToken, allowedReports);
        var result = await data.ToDataSourceResultAsync(request.ToDataSourceRequest(), cancellationToken);

        return Ok(result);
    }
}

Telerik Report Designer Controller

Example implementation for Telerik's web report designer:

[Authorize(Roles = "Telerik Report Edit")]
[Route("api/reportdesigner")]
[ApiExplorerSettings(IgnoreApi = true)]
public class TelerikReportDesignerController : ReportDesignerControllerBase
{
    public TelerikReportDesignerController(ReportServiceConfiguration reportServiceConfiguration, 
        ApplicationDbContext context, ICustomResolver resolver, 
        IReportDesignerServiceConfiguration reportDesignerServiceConfiguration, 
        IHttpContextAccessor accessor, IOptionsSnapshot<TelerikReportingOptions> options, 
        CancellationToken cancellationToken)
        : base(reportDesignerServiceConfiguration, reportServiceConfiguration)
    {
        // Custom initialization logic
    }

    public override async Task<IActionResult> GetReportAsync([FromQuery] string uri)
    {
        try
        {
            InstanceReportSource report = (InstanceReportSource)(await resolver.ResolveReport2(uri, null));
            
            string data;
            using (StringWriter stringWriter = new StringWriter())
            {
                new ReportJsonSerializer().Serialize(stringWriter, report.ReportDocument);
                data = stringWriter.ToString();
            }

            return Content(data, "application/json");
        }
        catch
        {
            return CreateJsonResponse(HttpStatusCode.NotFound, "Report with id '" + uri + "' not found.");
        }
    }
}

Telerik Report Viewer Controller

Example implementation for Telerik's report viewer with role-based access:

[Route("api/reports")]
[ApiController]
[Authorize(Roles = "Telerik Report View,Telerik Report Edit")]
[ApiExplorerSettings(IgnoreApi = true)]
public class TelerikReportController : ReportsControllerBase
{
    public override IActionResult CreateInstance(string clientID, [FromBody] ClientReportSource reportSource)
    {
        // Extract report name from report source
        string? reportName = null;
        if (reportSource?.Report != null)
        {
            reportName = Path.GetFileNameWithoutExtension(reportSource.Report);
        }

        if (!string.IsNullOrEmpty(reportName))
        {
            // Check if user has specific role for this report
            string requiredRole = TelerikReportLogic.RolePrefix + reportName;
            if (!User.IsInRole(requiredRole))
            {
                return Unauthorized($"You do not have permission to view this report. Required role: {requiredRole}");
            }
        }

        string tempInstanceID = Guid.NewGuid().ToString();
        return ReportControllerCommon.CreateInstance<int>(tempInstanceID, clientID, reportSource, resolver.controller, base.CreateInstance);
    }
}

File Upload and Download Examples

[DisableRequestSizeLimit]
[HttpPost("{id}")]
public async Task<ActionResult> Upload([FromRoute] string id, IFormFile file)
{
    if (file == null || file.Length == 0)
    {
        return StatusCode(500);
    }

    try
    {
        // Read the file data
        byte[] fileData;
        using (var memoryStream = new MemoryStream())
        {
            await file.CopyToAsync(memoryStream);
            fileData = memoryStream.ToArray();
        }

        // Find the latest version and create a new version
        int latestVersion = await db.ReportVersion
            .Where(rv => rv.ReportHeaderID == Guid.Parse(id))
            .OrderByDescending(rv => rv.Version)
            .Select(rv => rv.Version)
            .FirstOrDefaultAsync();

        var reportVersion = new ReportVersion
        {
            ReportHeaderID = Guid.Parse(id),
            Version = latestVersion + 1,
            BinaryData = fileData
        };

        db.ReportVersion.Add(reportVersion);
        await db.SaveChangesAsync();

        return Ok(new { Message = "File uploaded successfully", Version = reportVersion.Version });
    }
    catch (Exception ex)
    {
        return StatusCode(500, $"Internal server error: {ex.Message}");
    }
}

[HttpGet("{id}")]
public async Task<ActionResult> Download([FromRoute] string id, CancellationToken cancellationToken)
{
    Guid guid = Guid.Parse(id);
    ReportHeader reportHeader = await db.ReportHeader.FindAsync(guid);
    if (reportHeader == null)
    {
        return StatusCode(404);
    }

    byte[] reportData = (from rv in db.ReportVersion
                         where rv.ReportHeaderID == reportHeader.IDReportHeader
                         orderby rv.Version descending
                         select rv.BinaryData).FirstOrDefault();

    FileContentResult result = new FileContentResult(reportData, "application/octet-stream");
    Response.Headers["Content-Disposition"] = $"filename=\"{reportHeader.FileName}\"";

    return result;
}

Angular Integration

For Angular applications, you'll need the companion NPM package:

NPM Package: @ticomix/telerik-reporting

Angular Files Required

• src/typings.d.ts
• src/app/telerik-reporting/ folder with components
• src/app/standalone.service.ts
• src/app/standalone-routes.ts
• Update app.component.html for standalone page logic

Additional Dependencies

• Copy kendo.all.min.js to public/js folder

URL Rewriting (web.config)

For proper routing when designer/viewer opens in new tabs:

<system.webServer>
    <rewrite>
        <rules>
            <rule name="Angular Routes" stopProcessing="true">
                <match url="^(designer|viewer)(/.*)?$" />
                <conditions logicalGrouping="MatchAll">
                    <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
                    <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
                </conditions>
                <action type="Rewrite" url="/" />
            </rule>
        </rules>
    </rewrite>
</system.webServer>

MVC Integration

For MVC applications, the same server-side configuration applies. Additional MVC-specific views and controllers can be copied from Demo as needed.

Dependencies

Core Dependencies

• Telerik.Reporting (18.1.24.709)
• Telerik.Reporting.Services.AspNetCore (18.1.24.709)
• Telerik.WebReportDesigner.Services (18.1.24.709)
• Telerik.Reporting.OpenXmlRendering (18.1.24.709)
• Telerik.Reporting.WebServiceDataSource (18.1.24.709)

Utility Dependencies

• CsvHelper (33.0.1)
• Reinforced.Typings (1.6.3.21)
• DistributedLock.SqlServer (1.0.5)

Ticomix Dependencies

• Ticomix.EFCore (via project reference)

Support and Documentation

For Angular UI components and additional documentation, visit:

• Angular Components Documentation

Version Compatibility

• .NET 6.0+
• .NET 8.0+
• Entity Framework Core 6.0+
• SQL Server 2016+
• Angular 12+