private static void Process(IReport report)
        {
            string requesterName = report.UserName;
            string requesterEmail = report.Email ?? "[email protected]";

            string uploadToken = UploadFile(report.Attachment);

            string body = "{\"ticket\":{";

            body += string.Format("\"subject\": \"{0}\",", Correct(report.Title));

            body += Comment(report.Body, uploadToken);

            body += string.Format("\"requester\": {{\"name\": \"{0}\", \"email\": \"{1}\"}},"
                , Correct(requesterName), Correct(requesterEmail));

            body += string.Format("\"type\": \"{0}\",", report.Type == ReportType.Feedback ? "question" : "incident");

            body += string.Format("\"priority\": \"{0}\",", report.Type == ReportType.Crash ? "urgent" : "high");

            string tags = "\"tags\": [";
            for (int i = 0; i < report.Tags.Length; i++)
                tags += string.Format("{0}\"{1}\"", i == 0 ? "" : ", ", Correct(report.Tags[i]));
            tags += "]";
            body += tags;

            body += "}}";

            PostRequest(Url + "/api/v2/tickets.json", "application/json", body);
        }

        public IEnumerable<DataCollection> Grab(IReport report)
        {
            // define appropriate Cursor for current Report
            var cursor = _cursorSelector.DefineCursor(report);
            if (cursor == null)
                throw new ReportFormatException();

            // define appropriate Mapping for current Report from _mappings list
            var mapping = _mappings.FirstOrDefault(m =>
            {
                try { return cursor.CheckCondition(m.Match); }
                catch { return false; }
            });

            if (mapping == null)
                throw new MappingNotFoundException();

            var result = new List<DataCollection>();
            while (cursor.MoveNext(mapping.Range))
            {
                // define if current position should be skipped
                if (mapping.Rules != null)
                    if (mapping.Rules.Any(r => r.Name.ToLower() == "skip" && cursor.CheckCondition(r.Condition)))
                        continue;

                // get the DataCollection for all the Fields in the Mapping
                var collection = new DataCollection(mapping.Fields.Select(f => this.GetDataFromField(cursor, f)));
                if (collection.Values != null && collection.Values.Count > 0)
                    result.Add(collection);
            }

            return result;
        }

 public void display(IReport report)
 {
     var the_active_report = report.downcast_to<ActiveReport>();
     the_active_report.Run();
     ux_report_viewer.Document = the_active_report.Document;
     titled(report.name);
 }

 public Task<bool> SendReport(IReport report)
 {
     var tcs = new TaskCompletionSource<bool>();
     if (MFMailComposeViewController.CanSendMail)
     {
         var c = new MFMailComposeViewController();
         c.SetSubject(report.Title);
         c.SetToRecipients(new[] {_settings.DevelopersEmail});
         c.SetMessageBody(report.Body, false);
         NSData data = new NSString(report.Attachment).DataUsingEncoding(NSStringEncoding.UTF8);
         c.AddAttachmentData(data, "text/xml", "info.xml");
         _application.RootController.PresentViewController(c, true, null);
         c.Finished += (sender, e) =>
         {
             tcs.SetResult(e.Result == MFMailComposeResult.Sent);
             e.Controller.DismissViewController(true, null);
         };
     }
     else
     {
         var alert = new UIAlertView("Cannot send report", "E-mail messages not allowed", null, "OK");
         alert.Clicked += (sender, args) => tcs.SetResult(false);
         alert.Show();
     }
     return tcs.Task;
 }

        public ICursor DefineCursor(IReport report)
        {
            ICursor result = null;

            if (!String.IsNullOrEmpty(report.Filename))
            {
                // first, try to define the Cursor by file extension

                if (report.Filename.EndsWith(".xlsx", StringComparison.InvariantCultureIgnoreCase))
                {
                    // try to define Cursor by file extension (.xlsx => Excel 2007)
                    if ((result = this.TryExcel2007(report.Data)) != null)
                        return result;
                }
                else if (report.Filename.EndsWith(".xls", StringComparison.InvariantCultureIgnoreCase))
                {
                    // try to define Cursor by file extension (.xls => Excel 2003)
                    if ((result = this.TryExcel2003(report.Data)) != null)
                        return result;
                }
            }

            // if the Cursor is not defined yet than we should loop for all available Cursors

            if ((result = this.TryExcel2003(report.Data)) != null)
                return result;

            if ((result = this.TryExcel2007(report.Data)) != null)
                return result;

            return null;
        }

 public EasilyReportLog(string reportExportMode, string objType, string logFileName, IReport rpt)
 {
     mReportExportMode = reportExportMode;
     mObjType = objType;
     mLogFileName = logFileName;
     report = rpt;
 }

 public LocalPackageRepository(string physicalPath, IReport report, bool enableCaching)
     : this(new DefaultPackagePathResolver(physicalPath),
            new PhysicalFileSystem(physicalPath),
            report,
            enableCaching)
 {
 }

        private ActionResult PrepareFileResult(IReport report, string ext, bool download,
            byte[] renderedBytes, ReportRegistry.Report reportInfo)
        {
            string fileDownloadName;
            var customFileName = report as ICustomFileName;
            if (customFileName != null)
                fileDownloadName = customFileName.GetFileName();
            else
                fileDownloadName = (reportInfo.Title ?? reportInfo.Key) + "_" +
                    DateTime.Now.ToString("yyyyMMdd_HHss");

            fileDownloadName += "." + ext;

            if (download)
            {
                return new FileContentResult(renderedBytes, "application/octet-stream")
                {
                    FileDownloadName = fileDownloadName
                };
            }

            var cd = new ContentDisposition
            {
                Inline = true,
                FileName = fileDownloadName
            };

            Response.AddHeader("Content-Disposition", cd.ToString());
            return File(renderedBytes, UploadHelper.GetMimeType(fileDownloadName));
        }

        public HttpSource(
            string baseUri,
            string userName,
            string password,
            IReport report)
        {
            _baseUri = baseUri + (baseUri.EndsWith("/") ? "" : "/");
            _userName = userName;
            _password = password;
            _report = report;

            var proxy = Environment.GetEnvironmentVariable("http_proxy");
            if (string.IsNullOrEmpty(proxy))
            {
#if NET45
                _client = new HttpClient();
#else
                _client = new HttpClient(new Microsoft.Net.Http.Client.ManagedHandler());
#endif
            }
            else
            {
                // To use an authenticated proxy, the proxy address should be in the form of
                // "http://user:[email protected]:8888"
                var proxyUriBuilder = new UriBuilder(proxy);
#if NET45
                var webProxy = new WebProxy(proxy);
                if (string.IsNullOrEmpty(proxyUriBuilder.UserName))
                {
                    // If no credentials were specified we use default credentials
                    webProxy.Credentials = CredentialCache.DefaultCredentials;
                }
                else
                {
                    ICredentials credentials = new NetworkCredential(proxyUriBuilder.UserName,
                        proxyUriBuilder.Password);
                    webProxy.Credentials = credentials;
                }

                var handler = new HttpClientHandler
                {
                    Proxy = webProxy,
                    UseProxy = true
                };
                _client = new HttpClient(handler);
#else
                if (!string.IsNullOrEmpty(proxyUriBuilder.UserName))
                {
                    _proxyUserName = proxyUriBuilder.UserName;
                    _proxyPassword = proxyUriBuilder.Password;
                }

                _client = new HttpClient(new Microsoft.Net.Http.Client.ManagedHandler()
                {
                    ProxyAddress = new Uri(proxy)
                });
#endif
            }
        }

 public Robot(CommandSet commandSet, IReport reporter, Location bottomLeftBound, Location topRightBound)
 {
     _commandSet = commandSet;
     _reporter = reporter;
     _bottomLeftBound = bottomLeftBound;
     _topRightBound = topRightBound;
     Position = _commandSet.StartPosition;
 }

        public string PrintReport(IReport report)
        {
            var output = string.Format("##teamcity[buildStatus text='{{build.status.text}}, Build warnings: {0} ({1} unique)']\r\n", report.TotalEntriesCount, report.UniqueEntriesCount);
            output += string.Format("##teamcity[buildStatisticValue key='BuildWarnings' value='{0}']\r\n", report.TotalEntriesCount);
            output += string.Format("##teamcity[buildStatisticValue key='BuildWarningsUnique' value='{0}']\r\n", report.UniqueEntriesCount);

            return output;
        }

        public fmPictureView(IReport rpt, int index)
        {
            InitializeComponent();
            this.report = rpt;

            this.Text = ERptMultiLanguage.GetLanValue("fmPictureView");
            this.pictureBox.Image = this.report.Images[index].Image;
        }

        /// <summary>
        /// Generates a report filled with the content supplied by <paramref name="report"/>.
        /// </summary>
        /// <param name="report">Specifies the report model.</param>
        public void Generate(IReport report)
        {
            var contentBuilder = CreateContent(report);

            _fileWriter.Write(
                string.Concat(report.ReflectedAssembly, ".txt"),
                writer => writer.Write(contentBuilder.ToString()));
        }

        public fmEasilyReportDesigner(IReport rpt, IDesignerHost designerHost)
        {
            InitializeComponent();
            designReport = rpt;
            tempReport = rpt.Copy();

            componentChangeService = designerHost.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
        }

 public void AddReport(IReport report)
 {
     if (GetReport(report.Manufacturer, report.Model) != null)
     {
         throw new DuplicateEntryException(Constants.DUPLICATE);
     }
     Reports.Add(report);
 }

        /// <summary>
        /// The contructor function of frmProgress
        /// </summary>
        /// <param name="title">The title of the form</param>
        /// <param name="reportExport">The reportExport component to use</param>
        public fmProgress(string title, IReportExport reportExport, IReport rpt)
        {
            InitializeComponent();

            iReportExport = reportExport;
            td = new Thread(new ThreadStart(Begin));
            execSuccess = false;
            this.report = rpt;
        }

 public void Notify(IReport report)
 {
     IReportObserver observer;
     foreach (Object obj in _observers)
     {
         observer = (IReportObserver)obj;
         observer.Update(report);
     }
 }

        public void AddReport(IReport report)
        {
            if (this.Reports.Contains(report))
            {
                throw new DuplicateEntryException(Constants.DuplicateEntry);
            }

            this.Reports.Add(report);
        }

 public PackageFolder(
     string physicalPath,
     IReport report)
 {
     _repository = new LocalPackageRepository(physicalPath)
     {
         Report = report
     };
     _report = report;
 }

        public fmReportExport(IReport rpt)
        {
            InitializeComponent();
            designReport = rpt;
            tempReport = rpt.Copy();

            //ERptMultiLanguage.clientLanguageNum = 0;

            InitLanguage();
            InitComponentValue();
        }