private void btnSalesReport_Click(object sender, EventArgs e)
{
reportMode = ReportMode.SalesReport;
dateTimePicker1.Visible = dateTimePicker2.Visible = true;
lblPeriodFrom.Visible = lblPeriodTo.Visible = true;
lblPeriodFrom.Text = "Period From";
}
public void Run(ReportMode mode)
{
Profile profile = LoadProfile();
IEnumerable <Feed.Entry> entries = Entries();
ValidateProfile(profile);
ValidateEntries(profile, entries, mode);
}
public void Run(ReportMode mode)
{
Profile profile = LoadProfile();
IEnumerable<Feed.Entry> entries = Entries();
ValidateProfile(profile);
ValidateEntries(profile, entries, mode);
}
private void btnPastQuantities_Click(object sender, EventArgs e)
{
reportMode = ReportMode.PastQuantities;
dateTimePicker1.Visible = true;
dateTimePicker2.Visible = false;
lblPeriodFrom.Visible = true;
lblPeriodTo.Visible = false;
lblPeriodFrom.Text = "Period";
}
public Reporter(QueueWithLimit <T> queue, Producer <T> producer, Consumer <T> consumer,
ReportMode mode = ReportMode.verbose)
{
_queue = queue;
_producer = producer;
_consumer = consumer;
_mode = mode;
_goodBalances = 0;
_badBalances = 0;
}
private SettingsContainer MakeSettings(ReportMode reportMode = ReportMode.Off)
{
return(new SettingsContainer
{
UserSettings = new UserSettings
{
ReportMode = reportMode
}
});
}
public static void ReportAction(Bottle bottle, string message, ReportMode mode)
{
if (mode == ReportMode.Silent)
{
return;
}
lock (Locker)
{
Console.WriteLine($"Bottle ID {bottle.Id}: {message}");
}
}
private bool TryGetLoaderFromProjectPath(string projectFilePath, ReportMode mode, out IProjectFileLoader loader)
{
using (_dataGuard.DisposableWait())
{
// otherwise try to figure it out from extension
var extension = Path.GetExtension(projectFilePath);
if (extension.Length > 0 && extension[0] == '.')
{
extension = extension.Substring(1);
}
string language;
if (_extensionToLanguageMap.TryGetValue(extension, out language))
{
if (_workspace.Services.SupportedLanguages.Contains(language))
{
loader = _workspace.Services.GetLanguageServices(language).GetService <IProjectFileLoader>();
}
else
{
loader = null;
this.ReportFailure(mode, string.Format(WorkspacesResources.CannotOpenProjectUnsupportedLanguage, projectFilePath, language));
return(false);
}
}
else
{
loader = ProjectFileLoader.GetLoaderForProjectFileExtension(_workspace, extension);
if (loader == null)
{
this.ReportFailure(mode, string.Format(WorkspacesResources.CannotOpenProjectUnrecognizedFileExtension, projectFilePath, Path.GetExtension(projectFilePath)));
return(false);
}
}
// since we have both C# and VB loaders in this same library, it no longer indicates whether we have full language support available.
if (loader != null)
{
language = loader.Language;
// check for command line parser existing... if not then error.
var commandLineParser = _workspace.Services.GetLanguageServices(language).GetService <ICommandLineParserService>();
if (commandLineParser == null)
{
loader = null;
this.ReportFailure(mode, string.Format(WorkspacesResources.CannotOpenProjectUnsupportedLanguage, projectFilePath, language));
return(false);
}
}
return(loader != null);
}
}
public void Print(Report report, ReportMode mode)
{
if (mode == ReportMode.Full)
{
PrintFull(report);
}
else
{
PrintSummary(report);
}
}
private SettingsContainer MakeSettings(ReportMode reportMode = ReportMode.Off, bool consolidateUpdates = false)
{
return(new SettingsContainer
{
SourceControlServerSettings = new SourceControlServerSettings(),
UserSettings = new UserSettings
{
ReportMode = reportMode,
ConsolidateUpdatesInSinglePullRequest = consolidateUpdates
}
});
}
public void ValidateEntries(Profile profile, IEnumerable<Feed.Entry> entries, ReportMode mode)
{
ResourceValidator validator = new ResourceValidator(profile);
foreach (Feed.Entry entry in entries)
{
printer.Title(string.Format("Validating resource '{0}'", entry.Title));
Report report = validator.Validate(entry.ResourceNode);
printer.Print(report, mode);
Console.Write(".");
}
}
/// <summary>
/// Writes a GPU counter to guest memory.
/// </summary>
/// <param name="state">Current GPU state</param>
/// <param name="argument">Method call argument</param>
private void Report(GpuState state, int argument)
{
ReportMode mode = (ReportMode)(argument & 3);
ReportCounterType type = (ReportCounterType)((argument >> 23) & 0x1f);
switch (mode)
{
case ReportMode.Release: ReleaseSemaphore(state); break;
// case ReportMode.Counter: ReportCounter(state, type); break;
}
}
public void Report(ReportMode mode = ReportMode.Tree)
{
switch (mode)
{
case ReportMode.Tree:
ReportTree(rootEntry);
break;
case ReportMode.Method:
ReportMethods();
break;
}
}
/// <summary>
/// Initializes the BugSenseHandler object. Gets all the information about the system.
/// Subscribes to the UnhandledException event.
/// </summary>
/// <param name="apiKey">api key obtained from bugsense</param>
/// <param name="mode">connection mode: http or https</param>
public async Task Initialize(string apiKey, ReportMode mode = ReportMode.Normal)
{
if (_initialized) { return; }
_initialized = true;
_apiKey = apiKey;
_client = new BugSenseClient() { Name = ClientName, Version = Version };
_appEnv = new BugSenseEnvironment();
_appEnv.AppName = await EnvironmentHelper.GetAppDisplayName();
_appEnv.OsVersion = await EnvironmentHelper.GetOsVersion();
_mode = mode;
Windows.UI.Xaml.Application.Current.UnhandledException += Application_UnhandledException;
}
public static string ToReportString(this Def def, ReportMode mode)
{
if (mode == ReportMode.DefName)
{
return(def.defName);
}
if (mode == ReportMode.Label)
{
return(string.Format("\"{0}\"", def.label));
}
return(def.ToString());
}
public IFormReport GenerateNewReport(ReportMode mode, Worker worker, DateTime date)//подумац
{
switch (mode)
{
case ReportMode.DayReport:
return(System.FormDayReport(worker, date));
case ReportMode.BossReport:
return(System.FormBossReport(worker, date));
case ReportMode.FinalReport:
return(System.FormFinalReport(worker, date));
}
return(null);
}
private bool TryGetLoaderFromProjectPath(string projectFilePath, ReportMode mode, out IProjectFileLoader loader)
{
using (_dataGuard.DisposableWait())
{
// check to see if we already know the loader
if (!_projectPathToLoaderMap.TryGetValue(projectFilePath, out loader))
{
// otherwise try to figure it out from extension
var extension = Path.GetExtension(projectFilePath);
if (extension.Length > 0 && extension[0] == '.')
{
extension = extension.Substring(1);
}
string language;
if (_extensionToLanguageMap.TryGetValue(extension, out language))
{
if (this.Services.SupportedLanguages.Contains(language))
{
loader = this.Services.GetLanguageServices(language).GetService <IProjectFileLoader>();
}
else
{
this.ReportFailure(mode, string.Format(WorkspacesResources.CannotOpenProjectUnsupportedLanguage, projectFilePath, language));
return(false);
}
}
else
{
loader = ProjectFileLoader.GetLoaderForProjectFileExtension(this, extension);
if (loader == null)
{
this.ReportFailure(mode, string.Format(WorkspacesResources.CannotOpenProjectUnrecognizedFileExtension, projectFilePath, Path.GetExtension(projectFilePath)));
return(false);
}
}
if (loader != null)
{
_projectPathToLoaderMap[projectFilePath] = loader;
}
}
return(loader != null);
}
}
private void Report_Mode_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
{
switch (Report_Mode.SelectedIndex)
{
case 0:
report = ReportMode.WaitForQuery; break;
case 1:
report = ReportMode.Individual; break;
/*case 2:
* report = ReportMode.IndividualUnbuffered;break;*/
case 3:
report = ReportMode.BatchAfterStop; break;
default:
break;
}
}
public void Init(ReportMode mode)
{
Mode = mode;
switch (Mode)
{
case ReportMode.PlateNumber:
LeavingStatus = "parkingOccupied";
LeaveComment = "the spot is already taken";
break;
case ReportMode.Unreachable:
LeavingStatus = "parkingUnreachable";
LeaveComment = "there is a car on the street...";
break;
case ReportMode.NotFound:
LeavingStatus = "parkingMarkNotFound";
//LeaveComment = " there is no mark...";
break;
case ReportMode.Refund:
LeavingStatus = "parkingNotFound";
//LeaveComment = "there is no spot";
break;
case ReportMode.Full:
LeavingStatus = "parkingFull";
//LeaveComment = "the parking is full";
break;
case ReportMode.PictureRefuse:
LeavingStatus = "parkingRefused";
LeaveComment = "I refuse the spot";
break;
case ReportMode.CallOwner:
LeavingStatus = "leavingImpossible";
//LeaveComment = "I can’t leave the spot";
break;
case ReportMode.PictureLeave:
LeavingStatus = "problemReported";
LeaveComment = "I leave and report a problem";
break;
}
}
private string TryGetAbsolutePath(string path, ReportMode mode)
{
try
{
path = Path.GetFullPath(path);
}
catch (Exception)
{
ReportFailure(mode, string.Format(WorkspacesResources.Invalid_project_file_path_colon_0, path));
return(null);
}
if (!File.Exists(path))
{
ReportFailure(
mode,
string.Format(WorkspacesResources.Project_file_not_found_colon_0, path),
msg => new FileNotFoundException(msg));
return(null);
}
return(path);
}
private void ReportFailure(ReportMode mode, string message, Func <string, Exception> createException = null)
{
switch (mode)
{
case ReportMode.Throw:
if (createException != null)
{
throw createException(message);
}
else
{
throw new InvalidOperationException(message);
}
case ReportMode.Log:
_workspace.OnWorkspaceFailed(new WorkspaceDiagnostic(WorkspaceDiagnosticKind.Failure, message));
break;
case ReportMode.Ignore:
default:
break;
}
}
public bool OpenBudget(SqlConnection conn,
int commandTimeout = 30,
bool includeActivePeriods = false,
bool includeOrderBook = false)
{
try
{
reportMode = ReportMode.Budget;
CashFlow.Activate(); CashFlow.Range["A1"].Select();
Budget.Unprotect();
ClearWorksheet(Budget);
dataContext = new DataContext(conn);
dataContext.CommandTimeout = commandTimeout;
dataContext.Open();
SetActivePeriod(Budget, Properties.Resources.BudgetStatementTitle);
InitialiseWorksheet(Budget);
InitialisePeriods(Budget);
LoadCategories(Budget, CashType.Trade, includeActivePeriods, includeOrderBook, false);
dataContext.Close();
Budget.Activate();
FreezeFrames();
Budget.Protect();
return(true);
}
catch (Exception err)
{
DataContext data = new DataContext(conn);
data.ErrorLog($"{ err.Source}.{ err.TargetSite.Name} {err.Message}");
return(false);
}
}
public static bool OnClick(GameObject obj, Action cb, ReportMode report_mode = ReportMode.ReportError)
{
var btn = obj.GetComponent <Button>();
if (btn != null)
{
btn.onClick.AddListener(delegate() { cb(); });
return(false);
}
var trigger = obj.GetComponent <EventTrigger>();
if (trigger != null)
{
var handler = new EventTrigger.TriggerEvent();
handler.AddListener(delegate(BaseEventData data) { cb(); });
trigger.triggers.Add(new EventTrigger.Entry
{
eventID = EventTriggerType.PointerDown,
callback = handler
});
return(true);
}
switch (report_mode)
{
case ReportMode.ReportError:
Debug.LogErrorFormat("'{0}' is expected to have either an Button component or an EventTrigger component", obj.name);
return(false);
case ReportMode.Silence:
return(false);
default:
throw new Exception("Unhandled enum value " + report_mode);
}
}
private IRepositoryUpdater MakeRepositoryUpdater(
IPackageUpdater packageUpdater,
IPackageUpdateSelection updateSelection,
List <PackageUpdateSet> updates,
ReportMode reportMode = ReportMode.Off)
{
var sources = Substitute.For <INuGetSourcesReader>();
var updateFinder = Substitute.For <IUpdateFinder>();
var fileRestore = Substitute.For <IFileRestoreCommand>();
var reporter = Substitute.For <IAvailableUpdatesReporter>();
updateFinder.FindPackageUpdateSets(
Arg.Any <IFolder>(),
Arg.Any <NuGetSources>(),
Arg.Any <VersionChange>())
.Returns(updates);
packageUpdater.MakeUpdatePullRequest(
Arg.Any <IGitDriver>(),
Arg.Any <PackageUpdateSet>(),
Arg.Any <NuGetSources>(),
Arg.Any <RepositoryData>())
.Returns(true);
var settings = new UserSettings
{
ReportMode = reportMode
};
var repoUpdater = new RepositoryUpdater(
sources, updateFinder, updateSelection, packageUpdater,
Substitute.For <INuKeeperLogger>(), new SolutionsRestore(fileRestore),
reporter, settings);
return(repoUpdater);
}
private bool TryGetAbsoluteProjectPath(string path, string baseDirectory, ReportMode mode, out string absolutePath)
{
try
{
absolutePath = GetAbsolutePath(path, baseDirectory);
}
catch (Exception)
{
ReportFailure(mode, string.Format(WorkspacesResources.Invalid_project_file_path_colon_0, path));
absolutePath = null;
return(false);
}
if (!File.Exists(absolutePath))
{
ReportFailure(
mode,
string.Format(WorkspacesResources.Project_file_not_found_colon_0, absolutePath),
msg => new FileNotFoundException(msg));
return(false);
}
return(true);
}
public static void Report(ReportMode mode = ReportMode.Tree)
{
GetInstance().Report(mode);
}
private void btnReportQuantities_Click(object sender, EventArgs e)
{
reportMode = ReportMode.CurrentQuantities;
dateTimePicker1.Visible = dateTimePicker2.Visible = false;
lblPeriodFrom.Visible = lblPeriodTo.Visible = false;
}
private void ReportFailure(ReportMode mode, string message, Func<string, Exception> createException = null)
{
switch (mode)
{
case ReportMode.Throw:
if (createException != null)
{
throw createException(message);
}
else
{
throw new InvalidOperationException(message);
}
case ReportMode.Log:
_workspace.OnWorkspaceFailed(new WorkspaceDiagnostic(WorkspaceDiagnosticKind.Failure, message));
break;
case ReportMode.Ignore:
default:
break;
}
}
public bool OpenCashFlow(SqlConnection conn,
int commandTimeout = 30,
bool includeActivePeriods = false,
bool includeOrderBook = false,
bool includeBankBalances = false,
bool includeBankTypes = false,
bool includeTaxAccruals = false,
bool includeVatDetails = false,
bool includeBalanceSheet = false)
{
try
{
reportMode = ReportMode.CashFlow;
Budget.Activate(); Budget.Range["A1"].Select();
CashFlow.BeginInit();
CashFlow.Unprotect();
ClearWorksheet(CashFlow);
dataContext = new DataContext(conn);
dataContext.CommandTimeout = commandTimeout;
dataContext.Open();
SetActivePeriod(CashFlow, Properties.Resources.TextStatementTitle);
InitialiseWorksheet(CashFlow);
InitialisePeriods(CashFlow);
LoadCategories(CashFlow, CashType.Trade, includeActivePeriods, includeOrderBook, false);
LoadCategories(CashFlow, CashType.Money, false, false, false);
LoadTotals(CashFlow, CashType.Trade, CategoryType.Total);
LoadCategories(CashFlow, CashType.Tax, includeActivePeriods, false, includeTaxAccruals);
LoadTotals(CashFlow, CashType.Tax, CategoryType.Total);
LoadTotalsFormula(CashFlow);
LoadExpressions(CashFlow);
if (includeBankTypes)
{
LoadCategories(CashFlow, CashType.Money, false, false, false);
}
if (includeBankBalances)
{
LoadBankBalances(CashFlow);
}
if (includeVatDetails)
{
LoadVatRecurrenceTotals(CashFlow, includeActivePeriods, includeTaxAccruals);
LoadVatPeriodTotals(CashFlow, includeActivePeriods, includeTaxAccruals);
}
if (includeBalanceSheet)
{
LoadBalanceSheet(CashFlow);
}
dataContext.Close();
CashFlow.EndInit();
CashFlow.Activate();
FreezeFrames();
CashFlow.Protect();
return(true);
}
catch (Exception err)
{
dataContext = new DataContext(conn);
dataContext.ErrorLog($"{ err.Source}.{ err.TargetSite.Name} {err.Message}");
return(false);
}
}
private bool TryGetLoaderFromProjectPath(string projectFilePath, ReportMode mode, out IProjectFileLoader loader)
{
using (_dataGuard.DisposableWait())
{
// otherwise try to figure it out from extension
var extension = Path.GetExtension(projectFilePath);
if (extension.Length > 0 && extension[0] == '.')
{
extension = extension.Substring(1);
}
string language;
if (_extensionToLanguageMap.TryGetValue(extension, out language))
{
if (_workspace.Services.SupportedLanguages.Contains(language))
{
loader = _workspace.Services.GetLanguageServices(language).GetService<IProjectFileLoader>();
}
else
{
loader = null;
this.ReportFailure(mode, string.Format(WorkspacesResources.Cannot_open_project_0_because_the_language_1_is_not_supported, projectFilePath, language));
return false;
}
}
else
{
loader = ProjectFileLoader.GetLoaderForProjectFileExtension(_workspace, extension);
if (loader == null)
{
this.ReportFailure(mode, string.Format(WorkspacesResources.Cannot_open_project_0_because_the_file_extension_1_is_not_associated_with_a_language, projectFilePath, Path.GetExtension(projectFilePath)));
return false;
}
}
// since we have both C# and VB loaders in this same library, it no longer indicates whether we have full language support available.
if (loader != null)
{
language = loader.Language;
// check for command line parser existing... if not then error.
var commandLineParser = _workspace.Services.GetLanguageServices(language).GetService<ICommandLineParserService>();
if (commandLineParser == null)
{
loader = null;
this.ReportFailure(mode, string.Format(WorkspacesResources.Cannot_open_project_0_because_the_language_1_is_not_supported, projectFilePath, language));
return false;
}
}
return loader != null;
}
}
private bool TryGetAbsoluteProjectPath(string path, string baseDirectory, ReportMode mode, out string absolutePath)
{
try
{
absolutePath = GetAbsolutePath(path, baseDirectory);
}
catch (Exception)
{
ReportFailure(mode, string.Format(WorkspacesResources.Invalid_project_file_path_colon_0, path));
absolutePath = null;
return false;
}
if (!File.Exists(absolutePath))
{
ReportFailure(
mode,
string.Format(WorkspacesResources.Project_file_not_found_colon_0, absolutePath),
msg => new FileNotFoundException(msg));
return false;
}
return true;
}
///<summary>The type of report being requested.</summary>
public ReportingRequest(ReportType type, ReportMode mode)
: base()
{
this.type = type;
this.mode = mode;
}
private string TryGetAbsolutePath(string path, ReportMode mode)
{
try
{
path = Path.GetFullPath(path);
}
catch (Exception)
{
ReportFailure(mode, string.Format(WorkspacesResources.Invalid_project_file_path_colon_0, path));
return null;
}
if (!File.Exists(path))
{
ReportFailure(
mode,
string.Format(WorkspacesResources.Project_file_not_found_colon_0, path),
msg => new FileNotFoundException(msg));
return null;
}
return path;
}
private bool TryGetLoaderFromProjectPath(string projectFilePath, ReportMode mode, out IProjectFileLoader loader)
{
using (_dataGuard.DisposableWait())
{
// check to see if we already know the loader
if (!_projectPathToLoaderMap.TryGetValue(projectFilePath, out loader))
{
// otherwise try to figure it out from extension
var extension = Path.GetExtension(projectFilePath);
if (extension.Length > 0 && extension[0] == '.')
{
extension = extension.Substring(1);
}
string language;
if (_extensionToLanguageMap.TryGetValue(extension, out language))
{
if (this.Services.SupportedLanguages.Contains(language))
{
loader = this.Services.GetLanguageServices(language).GetService<IProjectFileLoader>();
}
else
{
this.ReportFailure(mode, string.Format(WorkspacesResources.CannotOpenProjectUnsupportedLanguage, projectFilePath, language));
return false;
}
}
else
{
loader = ProjectFileLoader.GetLoaderForProjectFileExtension(this, extension);
if (loader == null)
{
this.ReportFailure(mode, string.Format(WorkspacesResources.CannotOpenProjectUnrecognizedFileExtension, projectFilePath, Path.GetExtension(projectFilePath)));
return false;
}
}
if (loader != null)
{
_projectPathToLoaderMap[projectFilePath] = loader;
}
}
return loader != null;
}
}
//TODO: fix diet list
internal static void PrintCompatibilityReport(ReportMode mode, bool silent = false)
{
string text = "";
text = "\n========================== Complete food categories list ==========================\n\n";
var completeSortedList = (from entry in FoodCategoryUtils.FoodRecords
//where entry.Key.GetMod() != null
group entry by entry.Value.category);
foreach (var current in completeSortedList)
{
var completeSortedList2 = (from entry in current
group entry by entry.Key.GetMod());
if (completeSortedList2.Any())
{
text += string.Format("+-- Foods of category {0} {1}: --------- \n", current.Key, (current.Key == FoodCategory.Null) ? "(undetermined)" : "");
foreach (var modDefs in completeSortedList2)
{
text += string.Format("| [Mod : {0}]", modDefs.Key.Name);
text += " " + String.Join(" ; ", modDefs.Select((arg) => arg.Key.ToReportString(mode) + (arg.Value.costFactor != 1f ? "(cost: " + arg.Value.costFactor.ToString("F2") + ")" : "") + (arg.Key.HasForcedFoodPref() ? " (forced)" : "")).ToArray()) + "\n";
}
text += "|\n";
}
}
text += "\n========================== Complete diets list ==========================\n\n";
foreach (var policy in Policies.AllVisiblePolicies)
{
var allDietsSorted = (from entry in policy.PerRacesDiet
where entry.Key.GetMod() != null
group entry by entry.Key.GetMod());
var masks = string.Join(" ; ", policy.pawnMasks.Select((arg) => arg.ToString()).ToArray());
text += string.Format("+-- [Policy : {0}] {1} --------------- \n", policy.label, masks);
foreach (var mod in allDietsSorted)
{
text += string.Format("|\t[Mod : {0}]\n", mod.Key.Name);
foreach (var diet in mod)
{
var detailledDiet = new List <string>();
if (policy.unrestricted)
{
detailledDiet.Add("* Does not ever care *");
}
else
{
foreach (FoodCategory current in diet.Value.elements.Select((arg) => arg.foodCategory))
{
var foodsWithPrefForRace = DefDatabaseHelper.AllDefsIngestibleNAnimals.Where((arg) => arg.ingestible != null && arg.DetermineFoodCategory(true) == current && diet.Key.race.CanEverEat(arg));
var foodsWithPref = FoodCategoryUtils.GetAllFoodsWithPref(current);
int foodsWithPrefCount = foodsWithPref.Count();
string foodsList = "";
int gap = foodsWithPrefCount - foodsWithPrefForRace.Count();
if (foodsWithPrefCount == foodsWithPrefForRace.Count() && foodsWithPrefCount > 3)
{
foodsList = "*all*";
}
else if (4 >= gap && gap >= 1)
{
var excludeList = foodsWithPref.Where((arg) => !foodsWithPrefForRace.Contains(arg)).Select((arg) => arg.ToReportString(mode));
foodsList = string.Format("*all except* {0}", string.Join(";", excludeList.ToArray()));
}
else
{
foodsList = string.Join("=", foodsWithPrefForRace.Select((arg) => arg.ToReportString(mode)).ToArray());
}
detailledDiet.Add(string.Format("[{0} ({1})]", current, foodsList));
}
}
text += string.Format("|\t\t{0} :\t\t{1}\n", diet.Key.ToReportString(mode), string.Join(" > ", detailledDiet.ToArray()));
}
}
}
Log.Message(string.Format("Compatibility report ({0} lines) :\n{1}", text.Count((arg) => arg == '\n'), text));
if (!silent)
{
Messages.Message("ReportPrintedInLogMessage".Translate(), MessageTypeDefOf.NeutralEvent);
}
}
public void ValidateEntries(Profile profile, IEnumerable <Feed.Entry> entries, ReportMode mode)
{
ResourceValidator validator = new ResourceValidator(profile);
foreach (Feed.Entry entry in entries)
{
printer.Title(string.Format("Validating resource '{0}'", entry.Title));
Report report = validator.Validate(entry.ResourceNode);
printer.Print(report, mode);
Console.Write(".");
}
}
public void Print(Report report, ReportMode mode)
{
if (mode == ReportMode.Full)
PrintFull(report);
else
PrintSummary(report);
}
public async Task <IActionResult> GetReport(
int id,
ReportMode reportMode,
ExportType exportType,
string rdlReportName,
string entityName,
string ids,
string reportJsonData,
string userToken)
{
if (string.IsNullOrEmpty(userToken))
{
return(null);
}
UserInfo userInfo = GetUserInfoFromUserToken(userToken);
string reportJsonData1 = string.Empty;
if (!string.IsNullOrEmpty(reportJsonData))
{
byte[] encodedDataAsBytes = System.Convert.FromBase64String(reportJsonData);
string dataEncoded = System.Text.ASCIIEncoding.ASCII.GetString(encodedDataAsBytes);
reportJsonData1 = HttpUtility.UrlDecode(dataEncoded);
}
try
{
if (userInfo != null)
{
ReportGenerator gen = new ReportGenerator(
Settings.GetInstance.SystemSettings.ReportServerUrl + "/ReportExecution2005.asmx",
Settings.GetInstance.SystemSettings.ReportServerUserName,
Settings.GetInstance.SystemSettings.ReportServerPassword
);
string reportPath = Settings.GetInstance.SystemSettings.ReportServerFormsPath;
if (!reportPath.EndsWith("/"))
{
reportPath += "/";
}
if (reportMode == ReportMode.MultipleByMultipleIds)
{
byte[] encodedDataAsBytes = System.Convert.FromBase64String(ids);
string idsEncoded = System.Text.ASCIIEncoding.ASCII.GetString(encodedDataAsBytes);
string idsUrlEncoded = HttpUtility.UrlDecode(idsEncoded).Replace("[", "").Replace("]", "");
string[] idsUrlEncodedSplited = idsUrlEncoded.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (idsUrlEncodedSplited != null && idsUrlEncodedSplited.Length == 1)
{
int recordId = int.Parse(idsUrlEncodedSplited[0]);
return(await this.RenderReport(userInfo, entityName, recordId, reportPath + rdlReportName, exportType, gen));;
}
else
{
using (MemoryStream compressedFileStream = new MemoryStream())
{
using (ZipArchive zipArchive = new ZipArchive(compressedFileStream, ZipArchiveMode.Update, false))
{
foreach (string recordIdStr in idsUrlEncodedSplited)
{
int recordId = int.Parse(recordIdStr);
byte[] repData = await this.RenderReportData(userInfo, entityName, recordId, reportPath + rdlReportName, exportType, gen);
SqlReport sqlReport = new SqlReport(userInfo, this.auditService);
string reportNameReal = sqlReport.GetReportName(entityName, id);
ZipArchiveEntry zipEntry = zipArchive.CreateEntry(reportNameReal);
using (MemoryStream originalFileStream = new MemoryStream(repData))
{
using (Stream zipEntryStream = zipEntry.Open())
{
originalFileStream.CopyTo(zipEntryStream);
}
}
}
}
return(new FileContentResult(compressedFileStream.ToArray(), "application/zip")
{
FileDownloadName = "Reports.zip"
});
}
}
}
//**else if (reportMode == ReportMode.OneByMultipleIds)
//**{
//** byte[] encodedDataAsBytes = System.Convert.FromBase64String(ids);
//** string idsEncoded = System.Text.ASCIIEncoding.ASCII.GetString(encodedDataAsBytes);
//** string idsUrlEncoded = HttpUtility.UrlDecode(idsEncoded);
//**
//** Vistos3Api.Code.Reports.ReportSettings reportSettings = new Vistos3Api.Code.Reports.ReportSettings();
//** reportSettings.ReportPath = Settings.GetInstance.SystemSettings.ReportServerFormsPath;
//** reportSettings.ReportServerUserName = Settings.GetInstance.SystemSettings.ReportServerUserName;
//** reportSettings.ReportServerPassword = Settings.GetInstance.SystemSettings.ReportServerPassword;
//** reportSettings.ReportServerUrl = Settings.GetInstance.SystemSettings.ReportServerUrl;
//** if (!reportSettings.ReportPath.EndsWith("/")) reportSettings.ReportPath += "/";
//** reportSettings.ReportPath += rdlReportName;
//** reportSettings.ReportParameters.Add(new Microsoft.Reporting.WebForms.ReportParameter("ids", idsUrlEncoded));
//** if (!string.IsNullOrEmpty(reportJsonData1))
//** {
//** reportSettings.ReportParameters.Add(new Microsoft.Reporting.WebForms.ReportParameter("jsonData", reportJsonData1));
//** }
//**
//** string reportNameReal = reportSettings.GetReportName(entityName, id, userInfo);
//** ReportResult rr = new ReportResult(reportNameReal,
//** exportType,
//** reportSettings,
//** entityName,
//** userInfo,
//** entityName,
//** id,
//** false);
//**
//** return rr;
//**}
//**else
else if (reportMode == ReportMode.OneByOneId)
{
return(await this.RenderReport(userInfo, entityName, id, reportPath + rdlReportName, exportType, gen));
}
}
}
catch (Exception ex)
{
Logger.SaveLogError(LogLevel.Error, "Execute", ex, null, userInfo);
}
return(NotFound());
}
public static void Run <T>(ReportMode mode) where T : Tester, new()
{
Tester tester = new T();
tester.Run(mode);
}
public void Report(ReportMode mode)
{
}
