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 void CreateReport()
{
m_Report = ReportFactory.Create(m_Config.Format, m_Config.Output, m_Config.Layout, m_Config.Template, m_Config.ConfigParams);
foreach (PwGroup group in m_Config.Groups) {
m_Report.AddGroup(GetGroupPath(group));
foreach (PwEntry entry in group.Entries) {
string[] data = new string[m_Config.Layout.Count];
bool rowEnabled = true;
for (int i = 0; i < m_Config.Layout.Count; i++) {
data[i] = m_Config.Layout[i].EvaluateString(entry);
if (m_Config.Layout[i].Filter.Enabled)
if (!m_Config.Layout[i].Filter.Evaluate(data[i])) {
rowEnabled = false;
break;
}
}
if (rowEnabled) m_Report.AddRow(data);
}
}
if (ReportDoneEvent != null)
ReportDoneEvent(this, null);
m_Report.Close();
}
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 EasilyReportLog(string reportExportMode, string objType, string logFileName, IReport rpt)
{
mReportExportMode = reportExportMode;
mObjType = objType;
mLogFileName = logFileName;
report = rpt;
}
private static void Process(IReport report)
{
string requesterName = report.UserName;
string requesterEmail = report.Email ?? "*****@*****.**";
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 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 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 LocalPackageRepository(string physicalPath, IReport report, bool enableCaching)
: this(new DefaultPackagePathResolver(physicalPath),
new PhysicalFileSystem(physicalPath),
report,
enableCaching)
{
}
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://*****:*****@proxyaddress.com: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 fmEasilyReportDesigner(IReport rpt, IDesignerHost designerHost)
{
InitializeComponent();
designReport = rpt;
tempReport = rpt.Copy();
componentChangeService = designerHost.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
}
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 Robot(CommandSet commandSet, IReport reporter, Location bottomLeftBound, Location topRightBound)
{
_commandSet = commandSet;
_reporter = reporter;
_bottomLeftBound = bottomLeftBound;
_topRightBound = topRightBound;
Position = _commandSet.StartPosition;
}
/// <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 fmPictureView(IReport rpt, int index)
{
InitializeComponent();
this.report = rpt;
this.Text = ERptMultiLanguage.GetLanValue("fmPictureView");
this.pictureBox.Image = this.report.Images[index].Image;
}
public void AddReport(IReport report)
{
if (GetReport(report.Manufacturer, report.Model) != null)
{
throw new DuplicateEntryException(Constants.DUPLICATE);
}
Reports.Add(report);
}
public void Notify(IReport report)
{
IReportObserver observer;
foreach (Object obj in _observers)
{
observer = (IReportObserver)obj;
observer.Update(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 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();
}
public void AddReport(IReport report)
{
string key = this.ConcatStrings(report.Manufacturer, report.Model);
if (this.Reports.ContainsKey(key))
{
throw new DuplicateEntryException(Constants.Duplicate);
}
this.Reports.Add(key, report);
}
public static IReport CreateModel(IReport r)
{
return new
{
ReportID = (uint)r.ReportID,
ReportName = System.Enum.GetName(typeof(ReportType), r.ReportID),
Report = GetReport(r),
ParametersView = GetParametersViewName((ReportType)r.ReportID),
SerializedChild = r.SerializedChild,
FilterString = r.FilterString
}.ActLike<IReport>();
}
public ProfiledVirtualUserNetwork(RequestCommand command)
: base(command)
{
if (command.Reporting == null)
command.Reporting = Report.Null;
totalRequests = command.Requests.Count;
report = command.Reporting;
period = new ConcurrentBag<ProfileItem>();
periodPending = new ConcurrentDictionary<IRestRequest, RequestItem>();
signal = new AutoResetEvent(false);
}
/// <summary>
/// Transforms the specified report into a pre-determined format and
/// then stores the output in the stream.
/// </summary>
/// <param name="report">The report.</param>
/// <param name="fileWriter">
/// The delegate that is used to write the given stream to a file
/// with the specified name.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when <paramref name="report"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown when <paramref name="fileWriter"/> is <see langword="null" />.
/// </exception>
public void Transform(IReport report, Action<string, Stream> fileWriter)
{
{
Lokad.Enforce.Argument(() => report);
Lokad.Enforce.Argument(() => fileWriter);
}
var reportSection = CreateReportSectionXml(report);
var reportTemplate = EmbeddedResourceExtracter.LoadEmbeddedTextFile(
Assembly.GetExecutingAssembly(),
@"Sherlock.Shared.Core.Reporting.Templates.ReportTemplate.xml");
var builder = new StringBuilder(reportTemplate);
{
builder.Replace(@"${REPORT_VERSION}$", "1.0");
builder.Replace(@"${HOST_NAME}$", EscapeTextForUseInXml(report.Header.HostName));
builder.Replace(@"${USER_NAME}$", EscapeTextForUseInXml(report.Header.UserName));
builder.Replace(@"${SHERLOCK_VERSION}$", EscapeTextForUseInXml(report.Header.SherlockVersion.ToString()));
// Write the time in a round-trip fashion. Specify the 'o' formatter for this
builder.Replace(@"${TEST_START_TIME}$", EscapeTextForUseInXml(report.Header.StartTime.ToString("o", CultureInfo.CurrentCulture)));
builder.Replace(@"${TEST_END_TIME}$", EscapeTextForUseInXml(report.Header.EndTime.ToString("o", CultureInfo.CurrentCulture)));
builder.Replace(@"${PRODUCT_NAME}$", EscapeTextForUseInXml(report.Header.ProductName));
builder.Replace(@"${PRODUCT_VERSION}$", EscapeTextForUseInXml(report.Header.ProductVersion.ToString(CultureInfo.CurrentCulture)));
builder.Replace(@"${DESCRIPTION}$", EscapeTextForUseInXml(report.Header.Description));
builder.Replace(@"${TEST_RESULT}$", DetermineTestPassOrFail(report));
builder.Replace(@"${TEST_SECTIONS}$", reportSection);
}
// Write the data to an internal stream first. We do this because the
// StreamWriter will close the stream when it gets disposed. When that happens
// we won't be able to do anything with the output stream anymore (the stream
// data will be flushed but that's no good if we're working with a memory stream).
var resultStream = new MemoryStream();
var internalStream = new MemoryStream();
using (var writer = new StreamWriter(internalStream, Encoding.UTF8))
{
writer.Write(builder.ToString());
writer.Flush();
// Reset the stream position so that we can pump it.
internalStream.Position = 0;
internalStream.CopyTo(resultStream);
resultStream.Position = 0;
}
fileWriter("sherlock.report.xml", resultStream);
}
public fmSaveAsTemplate(IReport report, bool designTime)
{
InitializeComponent();
dbGateway = new DBGateway(report);
if (!designTime)
{
btOK.Text = ERptMultiLanguage.GetLanValue("btOK");
btCancel.Text = ERptMultiLanguage.GetLanValue("btCancel");
this.Text = ERptMultiLanguage.GetLanValue("fmSaveAsTemplate");
lbFileName.Text = ERptMultiLanguage.GetLanValue("lbTemplateName");
}
}
private static string CreateContent(IReport report)
{
var reportBuilder = new StringBuilder();
WriteHeader(report, reportBuilder);
foreach (var concern in report)
{
WriteConcern(concern, reportBuilder);
}
return reportBuilder.ToString();
}
//private List<DictionaryEntry> pictureList = new List<DictionaryEntry>();
//private DataTable dtImageList;
public fmPictures(IReport rpt)
{
InitializeComponent();
#region Init Language
this.Text = ERptMultiLanguage.GetLanValue("fmPictures");
this.btAdd.Text = ERptMultiLanguage.GetLanValue("btAdd");
this.btRemove.Text = ERptMultiLanguage.GetLanValue("btRemove");
this.btChange.Text = ERptMultiLanguage.GetLanValue("btChange");
this.btSelect.Text = ERptMultiLanguage.GetLanValue("btSelect");
this.lbPictures.Text = ERptMultiLanguage.GetLanValue("lbPictures");
#endregion
this.report = rpt;
}
public void FootTheBill(IInvoice invoice)
{
if (clients.Find(x=> x.Name == invoice.Patient.Name)!=null)
{
report = new Report() { Id = invoice.Id, Date = DateTime.Now, Status = true };
Console.WriteLine("The bill is paid");
if (Report != null) { Report(this, new ReportEventArgs(report)); }
}
else
{
report = new Report() { Id = invoice.Id, Date = DateTime.Now, Status = false };
Console.WriteLine("The invoice is not paid, we do not have such a client");
if (Report != null) { Report(this, new ReportEventArgs(report)); }
}
}
public PdfReportExporter(IReport rpt, ExportMode eMode, bool dMode)
{
report = rpt;
exportMode = eMode;
designMode = dMode;
log = new EasilyReportLog("Pdf Report", this.GetType().FullName, LogFileInfo.logFileName, rpt);
if (rpt.Format.PageHeight != 0.0)
{
exportByHeight = true;
}
else
{
exportByHeight = false;
}
}
protected override void SetDocumentSource(IReport report)
{
DocumentViewer.DocumentSource = report;
DocumentViewer.ZoomMode = ZoomMode;
}
static async Task MainAsync()
{
IList <WikimediaEntity> files = new List <WikimediaEntity>();
SearchFiles = new SearchFiles();
DownloadMultipleFiles = new DownloadMultipleFiles();
DecompressFiles = new DecompressFiles();
ProccessData = new ProccessData();
Report = new Report();
//var folderDetails = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
files = SearchFiles.GetLastFiles(3);
var resultDownload = await DownloadMultipleFiles.DownloadMultipleFilesAsync(files);
DecompressFiles.DecompressFilesByExtension(".gz");
Console.WriteLine("Procesando información , espere un momento por favor");
var data = await ProccessData.ProcessDataByDomainLanguage(resultDownload);
var reportLanguageDomain = Report.GetReportByLanguageDomain(data);
int cont = 0;
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("");
foreach (var item in reportLanguageDomain)
{
if (cont == 0)
{
Console.WriteLine("Period Language Domain ViewCount");
}
Console.WriteLine(item.period + " " + item.language + " " + item.domain + " " + item.viewCount);
cont++;
}
Console.WriteLine("Procesando información del siguiente reporte, espere un momento por favor.......");
var dataPage = await ProccessData.ProcessDataByPage(resultDownload);
var reportPage = Report.GetReportByPage(dataPage);
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("");
cont = 0;
foreach (var item in reportPage)
{
if (cont == 0)
{
Console.WriteLine("Period Page ViewCount");
}
Console.WriteLine(item.period + " " + item.page + " " + item.viewCount);
cont++;
}
//Reports.ForEach(report => Console.WriteLine(report));
Console.ReadLine();
}
protected abstract void SetDocumentSource(IReport report);
private void OnEnable()
{
_settings = Resources.Load <AtlasToolSettings>("AtlasToolSettings");
_sceneReport = new SceneReport();
_applicationReport = new ApplicationReport(_settings);
}
public SimpleStudentReportBuilder()
{
report = new Report();
}
public virtual string GetReport(IReport report)
{
return(account.GetReport(report));
}
public RestoreOperations(IReport report)
{
_report = report;
}
public SketchWatcher(IReport log, IFileSystem fileSystem)
{
_fileSystem = fileSystem;
_logger = new SketchLogWrapper(_logMessages, log);
_converter = Factory.CreateConverterWithSymbolsUxBuilder(_logger);
}
protected Upload(IUrl url, IReport report)
{
_url = new Lazy <IUrl>(() => url);
_report = new Lazy <IReport>(() => report);
}
public CodecovFallbackUploader(IUrl url, IReport report)
: base(url, report)
{
}
public AzureProvider(string key, IReport reportComparer)
{
SubscriptionKey = key;
ReportComparer = reportComparer;
}
public bool SaveReport <T>(IReport <T> report, string location)
{
return(WriteToFile(report.ToString(), location));
}
public IBankProduct Accept(IReport report)
{
return(report.Visit(this));
}
public ReportController(IReport Report)
{
_IReport = Report;
}
public void AddReport(IReport report)
{
m_reports.Add(report);
}
static Report()
{
Null = new NullReport();
}
public Uploads(IUrl url, IReport report)
{
_uploaders = new Lazy <IEnumerable <IUpload> >(() => SetUploaders(url, report));
}
protected void BindLocalReport(MsLocalReport localReport, IReport report)
{
ILocalReportProcessingLocation location = (ILocalReportProcessingLocation)report.ReportProcessingLocation;
localReport.LoadReportDefinition(ReportDefinitionCache.GetReportDefinition(location.File).GetReportStream());
localReport.EnableHyperlinks = true;
localReport.EnableExternalImages = true;
localReport.SetBasePermissionsForSandboxAppDomain(new System.Security.PermissionSet(System.Security.Permissions.PermissionState.Unrestricted));
if (localReport.IsDrillthroughReport)
{
localReport.SetParameters(localReport.OriginalParametersToDrillthrough);
}
else
{
IList <MsReportParameter> parameters = new List <MsReportParameter>();
foreach (IReportParameter parameter in report.ReportParameters)
{
parameters.Add(new MsReportParameter(parameter.Name, GetParameterValue(parameter)));
}
localReport.SetParameters(parameters);
}
localReport.DataSources.Clear();
foreach (IReportDataCommandTemplate reportDataCommandTemplate in report.ReportDataCommandTemplates)
{
DictionaryDataParameterValue parameterValues = new DictionaryDataParameterValue();
foreach (var dataParameterTemplate in reportDataCommandTemplate.Parameters)
{
var parameter = (IReportParameter)dataParameterTemplate;
if (localReport.IsDrillthroughReport)
{
parameterValues[parameter.Name] =
GetParameterValue(parameter, localReport.OriginalParametersToDrillthrough);
}
else
{
parameterValues[parameter.Name] = GetParameterValue(parameter);
}
}
var dataCommandTemplate = reportDataCommandTemplate as ReportDataCommandTemplate;
if (dataCommandTemplate != null)
{
using (IDataConnection connection = SimpleQuery.ConfigurationManagerConnection(dataCommandTemplate.DataSourceName))
{
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
DataTable table = null;
Boolean isOlap = ChangeOlapParameter(dataCommandTemplate.DataSourceName,
parameterValues);
if (reportDataCommandTemplate.Name.Equals("DealerGroupID"))
{
continue;
}
if (isOlap)
{
table = ReportAnalyticsClient.GetReportData <DataTable>(GetParameterList(parameterValues));
}
if (table == null)
{
using (IDataCommand command = connection.CreateCommand(reportDataCommandTemplate, parameterValues.DataParameterValue))
{
command.CommandTimeout = 200;
using (IDataReader reader = command.ExecuteReader())
{
table = (isOlap.Equals(true) ? DataTableMapper.ToOlapDataTable(reader, reportDataCommandTemplate.DataMap, new DataTableCallback()) :
DataTableMapper.ToDataTable(reader, reportDataCommandTemplate.DataMap, new DataTableCallback()));
}
}
}
localReport.DataSources.Add(new MsReportDataSource(reportDataCommandTemplate.Name, table));
}
}
}
localReport.Refresh();
}
public ReportService(IReport report)
{
_report = report;
}
public bool SaveReport <T>(IReport <T> report)
{
return(SaveReport(report, _appSettings.ReportFilesLocation));
}
public void RemoveReport(IReport report) => this.Reports[report.Manufacturer].Remove(report);
public static int Run(List <string> args)
{
var fuse = FuseApi.Initialize("Fuse", args);
Log = fuse.Report;
Log.Info("Version " + fuse.Version);
if (args.Contains("--version"))
{
Console.Out.WriteVersion(fuse.Version);
return(0);
}
// Launch services adds -psn_something to the programs argument list
// After moving an app from a dmg, and then starting the app
var psnArgIdx = args.FindIndex(str => str.StartsWith("-psn"));
if (psnArgIdx >= 0)
{
args.RemoveAt(psnArgIdx);
}
if (Platform.OperatingSystem == OS.Mac)
{
SetMinimumThreads(6); // For faster task creation in Mono. Mono doesn't have a good task system
}
var shell = new Shell();
if (fuse.IsInstalled && shell.IsInsideRepo(AbsoluteDirectoryPath.Parse(Directory.GetCurrentDirectory())))
{
Log.Error("Please don't run installed Fuse from inside the Fuse repository. It will get confused by .unoconfigs.", ReportTo.LogAndUser);
return(1);
}
var program =
new CliProgram(
Log,
ColoredTextWriter.Out,
ColoredTextWriter.Error,
FuseCommandName,
() =>
{
MoveSdkConfigTmpBackCompatibleThing(shell);
},
DashboardCommand.CreateDashboardCommand(),
OpenCommand.CreateOpenCommand(),
new LazyCliCommand("daemon", "Start the fuse daemon", false, () => DaemonCommand.CreateDaemonCommand()),
new LazyCliCommand("daemon-client", "Create a connection to a daemon.", false, () => DaemonClientCommand.Create()),
new LazyCliCommand("preview", "Preview an app", false, () => PreviewCommand.CreatePreviewCommand()),
new LazyCliCommand("build", "Build a project for a given target", false, () => BuildCommand.CreateBuildCommand()),
new LazyCliCommand("create", "Create a project or file from a template", false, () => CreateCommand.CreateCreateCommand()),
new LazyCliCommand("install", "Install an external component", false, () => InstallCommand.CreateInstallCommand()),
new LazyCliCommand("event-viewer", "Dump all events", true, () => EventViewerCommand.CreateEventViewerCommand()),
new LazyCliCommand("tutorial", "Go to tutorials and guides", false, () => TutorialCommand.CreateTutorialCommand()),
new LazyCliCommand("import", "Import a file to your fuse project", false, () => ImportCommand.CreateImportCommand()),
new LazyCliCommand("reset-preview", "Causes all active previews to reset to the default state.", true, () => ResetPreviewCliCommand.CreateResetPreviewCommand()),
new LazyCliCommand("kill-all", "Kill all Fuse processes (even the daemon)", false, () => KillAllCommand.CreateKillAllCommand()),
new LazyCliCommand("unoconfig", "Print uno config", false, () => UnoConfigCommand.CreateUnoConfigCommand()));
var ctSource = new CancellationTokenSource();
Console.CancelKeyPress += (sender, eventArgs) => ctSource.Cancel();
return(program.Main(args.ToArray(), ctSource.Token));
}
public ReportController()
{
processInst = new Report <TReport, TParam>();
ReportPath = GetReportPath();
}
protected void addItem(ref IList <string> columns, ref ReportDataRow reportDataRow, ref IList <IReportRow> reportRows, IReport item)
{
foreach (var column in columns)
{
ReportDataCell reportDataCell = new ReportDataCell();
Tuple <ReportColumnType, object> field = item.getVirtualColumnValue(column.Replace(this.Parent.Name + "$" + this.Name + ".", ""));
ReportColumnType type = field.Item1;
switch (type)
{
case ReportColumnType.Integer:
reportDataCell.GenericValue = Convert.ToInt32(field.Item2);
break;
case ReportColumnType.String:
reportDataCell.GenericValue = Convert.ToString(field.Item2);
break;
case ReportColumnType.DateTime:
reportDataCell.GenericValue = Convert.ToDateTime(field.Item2);
break;
case ReportColumnType.Boolean:
reportDataCell.GenericValue = Convert.ToBoolean(field.Item2);
break;
}
reportDataRow.Cells.Add(reportDataCell);
}
reportRows.Add(reportDataRow);
}
public MnemonicSevice(IReport rep)
{
report = rep;
inputService = new InputService();
calc = new EllipticCurveCalculator();
}
public ArmoryService(IReport rep)
{
report = rep;
inputService = new InputService();
}
public void Accept(IReport report)
{
report.Visit(this);
}
public ReportService(IReport report)
{
this._report = report;
}
public Uploads(IUrl url, IReport report, IEnumerable <string> features)
{
_uploaders = new Lazy <IEnumerable <IUpload> >(() => SetUploaders(url, report, features));
}
/// <summary>
/// Render report to source C# code
/// </summary>
/// <param name="report"></param>
/// <param name="streams"></param>
public void Render(IReport report, StreamProvider streams)
{
Render(report, streams, null);
}
