private static List <string> WriteExcelResultFiles([NotNull] ScenarioSliceParameters parameters,
[NotNull] Func <string, ScenarioSliceParameters, bool, string> makeAndRegisterFullFilename,
ProcessingMode processingMode,
[NotNull] ProfileGenerationRo pgRo)
{
List <string> excelFileNames = new List <string>();
var fn1 = makeAndRegisterFullFilename("AllGeneratedLoadProfilesAndEnergy." + processingMode + ".Tree.xlsx", parameters, true);
excelFileNames.Add(fn1);
pgRo.DumpToExcel(fn1, XlsResultOutputMode.Tree);
var fn2 = makeAndRegisterFullFilename("AllGeneratedLoadProfilesAndEnergy." + processingMode + ".Full.xlsx", parameters, true);
pgRo.DumpToExcel(fn2, XlsResultOutputMode.FullLine);
excelFileNames.Add(fn2);
var fn3 = makeAndRegisterFullFilename("AllGeneratedLoadProfilesAndEnergy." + processingMode + ".ByTrafoStationTree.xlsx",
parameters,
true);
excelFileNames.Add(fn3);
pgRo.DumpToExcel(fn3, XlsResultOutputMode.ByTrafoStationTree);
var fn4 = makeAndRegisterFullFilename("AllGeneratedLoadProfilesAndEnergy." + processingMode + ".ByTrafoStationHausanschlussTree.xlsx",
parameters,
true);
excelFileNames.Add(fn4);
pgRo.DumpToExcel(fn4, XlsResultOutputMode.ByTrafoStationHausanschlussTree);
return(excelFileNames);
}
private static void WriteBrokenLpgCalcCleanupBatch([NotNull] ScenarioSliceParameters parameters,
[NotNull] Func <string, ScenarioSliceParameters, bool, string> makeAndRegisterFullFilename,
ProcessingMode processingMode,
[NotNull][ItemNotNull] List <string> brokenLpgDirectories,
[NotNull][ItemNotNull] List <string> brokenLpgJsons)
{
var lpgCleaner = makeAndRegisterFullFilename("CleanBrokenLPGStuff." + processingMode + "." + parameters.GetFileName() + ".cmd",
parameters,
true);
Encoding utf8WithoutBom = new UTF8Encoding(false);
FileStream fs = new FileStream(lpgCleaner, FileMode.Create);
StreamWriter sw = new StreamWriter(fs, utf8WithoutBom);
sw.WriteLine("chcp 65001");
foreach (string brokenLpgDirectory in brokenLpgDirectories)
{
sw.WriteLine("rmdir /S /Q \"" + brokenLpgDirectory + "\" ");
}
foreach (string brokenLpgJson in brokenLpgJsons)
{
sw.WriteLine("del \"" + brokenLpgJson + "\" ");
}
sw.Close();
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportServerUrl">The URL for the report server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="username">The report server username.</param>
/// <param name="password">The report server password.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <param name="filename">Output filename</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
string reportServerUrl,
IEnumerable <KeyValuePair <string, object> > reportParameters,
string username = null,
string password = null,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary <string, DataTable> localReportDataSources = null,
string filename = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportPath,
reportServerUrl,
username,
password,
reportParameters,
mode,
localReportDataSources,
filename);
return(reportRunner.Run());
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
string reportServerUrl,
string username,
string password,
IEnumerable <KeyValuePair <string, object> > reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary <string, DataTable> localReportDataSources = null,
string filename = null)
{
ReportFormat = reportFormat;
_filename = filename;
_viewerParameters.ProcessingMode = mode;
if (mode == ProcessingMode.Local && localReportDataSources != null)
{
_viewerParameters.LocalReportDataSources = localReportDataSources;
}
_viewerParameters.ReportPath = reportPath;
_viewerParameters.ReportServerUrl = reportServerUrl ?? _viewerParameters.ReportServerUrl;
if (username != null || password != null)
{
_viewerParameters.Username = username;
_viewerParameters.Password = password;
}
ParseParameters(reportParameters);
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportServerUrl">The URL for the report server.</param>
/// <param name="username">The report server username.</param>
/// <param name="password">The report server password.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <param name="filename">Output filename</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
string reportServerUrl,
string username = null,
string password = null,
object reportParameters = null,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary <string, DataTable> localReportDataSources = null,
string filename = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportPath,
reportServerUrl,
username,
password,
HtmlHelper.AnonymousObjectToHtmlAttributes(reportParameters),
mode,
localReportDataSources,
filename);
return(reportRunner.Run());
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
: this(reportFormat, reportPath, null, null, null, null, mode, localReportDataSources)
{
}
private void ChangeMode(ProcessingMode mode)
{
if (State != mode)
{
_screen.WriteLine($"Mode {State}=>{mode}");
State = mode;
}
}
public override string ToString()
{
if (ProcessingMode == HL7Table.ProcessingMode.None)
{
return(ProcessingID.Value());
}
return(ProcessingID.Value() + "^" + ProcessingMode.Value());
}
public override void InitCamera()
{
_prevCamQuality = CamQuality;
_prevCamMode = CamMode;
ImageProcessing.SetOvrCamera((int)CamQuality, (int)CamMode);
UpdateCameraProperties(true);
}
public void SetMode(ProcessingMode mode)
{
if (State != mode)
{
State = mode;
_screen.WriteLine($"Mode changed to {mode}");
}
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary <string, DataTable> localReportDataSources = null)
: this(reportFormat, reportPath, null, null, null, null, mode, localReportDataSources)
{
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
IEnumerable<KeyValuePair<string, object>> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
: this(reportFormat, reportPath, null, null, null, reportParameters, mode, localReportDataSources)
{
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
IEnumerable <KeyValuePair <string, object> > reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary <string, DataTable> localReportDataSources = null)
: this(reportFormat, reportPath, null, null, null, reportParameters, mode, localReportDataSources)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Logger"/> class.
/// </summary>
/// <param name="name">The name of the logger.</param>
/// <param name="level">The logging level of the logger.</param>
/// <param name="logProviders">A collection of <see cref="ILogProvider"/> objects used by this logger.</param>
/// <param name="isDisabled">A value indicating whether the logger is disabled.</param>
/// <param name="processingMode">A value that indicates how the logger will process logs.</param>
/// <param name="contextProviders">
/// A collection of <see cref="IContextProvider"/> objects that customize outgoing log entries.
/// </param>
public Logger(
string name = DefaultName,
LogLevel level = LogLevel.NotSet,
[AlternateName("providers")] IReadOnlyCollection <ILogProvider> logProviders = null,
bool isDisabled = false,
ProcessingMode processingMode = ProcessingMode.Background,
IReadOnlyCollection <IContextProvider> contextProviders = null)
: this(GetLogProcessor(processingMode), name, level, logProviders, isDisabled, contextProviders)
{
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
{
var reportRunner = new ReportRunner(reportFormat, reportPath, mode, localReportDataSources);
return reportRunner.Run();
}
// -------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------
public ColladaMinecraft(IFactory factory)
: base(factory)
{
this.arguments = factory.Resolve<ICommandLineArguments>();
this.modelBoundingBox = new BoundingBox(new Vector3(0), new Vector3(0));
this.blocks = new Dictionary<Block, Block>();
this.mode = ProcessingMode.ColladaToSchematic;
}
public MainWindow()
{
InitializeComponent();
//Start with brightness as selection for mode
BrightnessMode.IsChecked = true;
_mode = ProcessingMode.Brightness;
_player = new MediaPlayer();
EnablePlaybackControls(_player.Loaded);
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary <string, DataTable> localReportDataSources = null)
{
var reportRunner = new ReportRunner(reportFormat, reportPath, mode, localReportDataSources);
return(reportRunner.Run());
}
protected override bool RegisterCommandLineArguments()
{
ICommandLineSwitchDefinition definition = this.arguments.Define("s", "sourceFile", x => this.sourceFile = new CarbonFile(x));
definition.Required = true;
definition.RequireArgument = true;
definition.Description = "The source file to process";
definition = this.arguments.Define("m", "mode", x => this.mode = (ProcessingMode)Enum.Parse(typeof(ProcessingMode), x));
definition.RequireArgument = true;
definition.Description = "The processing mode";
return true;
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
IDictionary<string, object> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
: this(reportFormat,
reportPath,
reportParameters != null ? reportParameters.ToList() : null,
mode,
localReportDataSources)
{
}
//--- Constructors ---
public Element(string[] names, ProcessingMode mode, params Attribute[] attributes)
{
if (ArrayUtil.IsNullOrEmpty(names))
{
throw new ArgumentNullException("names");
}
this.Names = names;
this.Mode = mode;
foreach (Attribute attribute in attributes)
{
this.Attributes[attribute.Name] = attribute;
}
}
private void AddChunkToCache(JobChunkUid chunkUid, ProcessingMode mode)
{
var chunkKey = GetJobChunkKey(chunkUid, mode);
var chunkStatus = new JobChunkStatus()
{
LastUpdate = DateTime.Now,
Status = mode == ProcessingMode.Map ? ChunkStatus.NewMap : ChunkStatus.NewReduce
};
chunkStatus.ChunkUid.JobId = chunkUid.JobId;
chunkStatus.ChunkUid.ChunkId = chunkUid.ChunkId;
AzureClient.Instance.CacheClient.Add(chunkKey, chunkStatus);
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
IDictionary <string, object> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary <string, DataTable> localReportDataSources = null)
: this(
reportFormat,
reportPath,
reportParameters != null ? reportParameters.ToList() : null,
mode,
localReportDataSources)
{
}
/// <summary>
/// All buttons clicked
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void AllButtonsClick(object sender, EventArgs e)
{
try
{
if (sender == this.MainForm.ButtonBeginDump)
{
if (Controller.IsStartButton(this.MainForm.ButtonBeginDump) == true)
{
this.DumpController_.Validate();
this.MainForm.SaveUIState();
this.KeepFilesMode = ProcessingMode.DumpMode;
StaticMethods.ReInitializeThread(ref this.ThreadRunOperations,
true,
new ThreadStart(this.DoProcessing));
}
else
{
StaticMethods.ReInitializeThread(ref this.ThreadRunOperations,
false,
new ThreadStart(this.DoProcessing));
}
}
else
if (sender == this.MainForm.ButtonBeginImport)
{
if (Controller.IsStartButton(this.MainForm.ButtonBeginImport) == true)
{
this.ImportController_.Validate();
this.MainForm.SaveUIState();
this.KeepFilesMode = ProcessingMode.ImportMode;
StaticMethods.ReInitializeThread(ref this.ThreadRunOperations,
true,
new ThreadStart(this.DoProcessing));
}
else
{
StaticMethods.ReInitializeThread(ref this.ThreadRunOperations,
false,
new ThreadStart(this.DoProcessing));
}
}
}
catch (Exception em)
{
StaticMethods.DisplayErrorMessage(this.MainForm,
null,
false,
em.Message);
}
}
/// <summary>
/// Calculates the corresponding amplitude and frequency of a pixel from _image.
/// </summary>
/// <param name="x">x-coordinate of pixel</param>
/// <param name="y">y-coordinate of pixel</param>
/// <param name="mode"></param>
/// <returns>Data object with amplitude and frequency</returns>
private AudioData ProcessPixel(int x, int y, ProcessingMode mode)
{
var pixelColor = _image.GetPixel(x, y);
float amplitudeFactor = GetAmplitudeForColorAndMode(pixelColor, mode);
//Use frequency table
int frequency = (int)_frequencies[y];
return(new AudioData()
{
Frequency = frequency,
Amplitude = amplitudeFactor
});
}
private void button3_Click(object sender, EventArgs e)
{
if (textInput.Text != "" && textOutput.Text != "")
{
processingMode = new ProcessingMode(outputMode, inputDirectory, outputDirectory);
thread = new Thread(new ThreadStart(BackgroundConvert));
Lockdown(false);
convState = 1;
thread.Start();
}
else
{
MessageBox.Show("Please specify input/output files/directories.");
}
}
public void AddMessageQueue <TRequest, TResponse>(object service, ProcessingMode messageProcessingMode)
{
var messageQueue = queueCache.GetOrAdd(service, messageProcessingMode);
var messageSignature = GetMessageSignature <TRequest, TResponse>();
var handlersForThisMessageSignature = messageQueues.GetOrAdd(messageSignature, t => new ConcurrentBag <IMessageQueue>());
if (handlersForThisMessageSignature.Contains(messageQueue))
{
throw new InvalidOperationException(string.Format("This service has already been registered as a handler for message type {0}", messageSignature));
}
handlersForThisMessageSignature.Add(messageQueue);
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
IReportLoader reportLoader,
ProcessingMode mode,
IEnumerable<IDataSource> reportDataSources = null,
IEnumerable<ISubReportDataSource> subReportDataSources = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportLoader,
mode,
reportDataSources,
subReportDataSources);
return reportRunner.Run();
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
IEnumerable<KeyValuePair<string, object>> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportPath,
reportParameters,
mode,
localReportDataSources);
return reportRunner.Run();
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
string reportPath,
object reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportPath,
HtmlHelper.AnonymousObjectToHtmlAttributes(reportParameters),
mode,
localReportDataSources);
return reportRunner.Run();
}
private static ILogProcessor GetLogProcessor(ProcessingMode processingMode)
{
switch (processingMode)
{
case ProcessingMode.Background:
return(_backgroundLogProcessor.Value);
case ProcessingMode.Synchronous:
return(new SynchronousLogProcessor());
case ProcessingMode.FireAndForget:
return(new FireAndForgetLogProcessor());
default:
throw new ArgumentException($"Processing mode is not defined: {processingMode}.", nameof(processingMode));
}
}
/// <summary>Initializes the scheduler.</summary>
/// <param name="pair">The parent pair.</param>
/// <param name="maxConcurrencyLevel">The maximum degree of concurrency this scheduler may use.</param>
/// <param name="processingMode">The processing mode of this scheduler.</param>
internal ConcurrentExclusiveTaskScheduler(ConcurrentExclusiveSchedulerPair pair, int maxConcurrencyLevel, ProcessingMode processingMode)
{
Contract.Requires(pair != null, "Scheduler must be associated with a valid pair.");
Contract.Requires(processingMode == ProcessingMode.ProcessingConcurrentTasks || processingMode == ProcessingMode.ProcessingExclusiveTask,
"Scheduler must be for concurrent or exclusive processing.");
Contract.Requires(
(processingMode == ProcessingMode.ProcessingConcurrentTasks && (maxConcurrencyLevel >= 1 || maxConcurrencyLevel == UNLIMITED_PROCESSING)) ||
(processingMode == ProcessingMode.ProcessingExclusiveTask && maxConcurrencyLevel == 1),
"If we're in concurrent mode, our concurrency level should be positive or unlimited. If exclusive, it should be 1.");
m_pair = pair;
m_maxConcurrencyLevel = maxConcurrencyLevel;
m_processingMode = processingMode;
m_tasks = (processingMode == ProcessingMode.ProcessingExclusiveTask) ?
(IProducerConsumerQueue <Task>) new SingleProducerSingleConsumerQueue <Task>() :
(IProducerConsumerQueue <Task>) new MultiProducerMultiConsumerQueue <Task>();
}
/// <summary>
/// Add a single rule to the instance.
/// </summary>
/// <param name="rule">Rule to add.</param>
public void AddRule(string rule)
{
if (string.IsNullOrEmpty(rule))
{
return;
}
rule = rule.Trim();
if (rule.StartsWith("#"))
{
return;
}
ProcessingMode mode = ProcessingMode.Default;
switch (rule[0])
{
case '-':
mode = ProcessingMode.RemoveEmpty;
rule = rule.Substring(1);
break;
case '+':
mode = ProcessingMode.PadEmpty;
rule = rule.Substring(1);
break;
}
int square = rule.IndexOf('[');
if (square >= 0)
{
string[] names = rule.Substring(0, square).Split('/');
List <Attribute> attributes = new List <Attribute>();
foreach (string attr in rule.Substring(square + 1).TrimEnd(']').Split('|'))
{
// TODO (steveb): we should support '=' and '<' for default and valid values set
int sep = attr.IndexOfAny(new char[] { '=', '<' });
attributes.Add(new Attribute((sep >= 0) ? attr.Substring(0, sep) : attr, null));
}
Add(new Element(names, mode, attributes.ToArray()));
}
else
{
Add(rule);
}
}
/// <summary>
/// Gets the percentage of the maximum amplitude a color should output
/// </summary>
/// <param name="pixelColor"></param>
/// <param name="mode"></param>
/// <returns></returns>
private float GetAmplitudeForColorAndMode(Color pixelColor, ProcessingMode mode)
{
switch (mode)
{
case ProcessingMode.Brightness:
return(pixelColor.GetBrightness());
case ProcessingMode.Darkness:
return(1 - pixelColor.GetBrightness());
case ProcessingMode.Mode3:
break;
case ProcessingMode.Mode4:
break;
}
return(0);
}
/// <summary>
/// Sets the processing mode to the mode represented by the radio button that triggered this event.
/// </summary>
/// <param name="sender">Mode radio button</param>
/// <param name="e"></param>
private void ModeSelection_Click(object sender, RoutedEventArgs e)
{
if (sender.Equals(BrightnessMode))
{
_mode = ProcessingMode.Brightness;
}
else if (sender.Equals(DarknessMode))
{
_mode = ProcessingMode.Darkness;
}
else if (sender.Equals(Mode3))
{
_mode = ProcessingMode.Mode3;
}
else if (sender.Equals(Mode4))
{
_mode = ProcessingMode.Mode4;
}
}
private void ReloadSettings()
{
// load new settings
ImageProcessing.GetCamJsonProperties(GetPropertyCallback);
// make sure settings are synced, in case a value was out of range
CamMode = (ProcessingMode)_sourceSettings.Mode;
Gain = _sourceSettings.Gain;
Exposure = _sourceSettings.Exposure;
BLC = _sourceSettings.BLC;
AutoWhiteBalance = _sourceSettings.AutoWhiteBalance;
WhiteBalanceR = _sourceSettings.WhiteBalanceR;
WhiteBalanceG = _sourceSettings.WhiteBalanceG;
WhiteBalanceB = _sourceSettings.WhiteBalanceB;
AutoContrast = _sourceSettings.AutoContrast;
AutoContrastAutoGain = _sourceSettings.AutoContrastAutoGain;
AutoContrastClipHistPercent = _sourceSettings.AutoContrastClipHistPercent;
AutoContrastMax = _sourceSettings.AutoContrastMax;
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
IReportLoader reportLoader,
IEnumerable<KeyValuePair<string, object>> reportParameters,
ProcessingMode mode,
IEnumerable<IDataSource> reportDataSources = null,
IEnumerable<ISubReportDataSource> subReportDataSources = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportLoader,
reportParameters,
mode,
reportDataSources,
subReportDataSources);
return reportRunner.Run();
}
public static string GetString(ProcessingMode mode)
{
string ret = "";
switch (mode)
{
case ProcessingMode.Activity:
ret = "appointment_only";
break;
case ProcessingMode.Inventory:
ret = "inventory_only";
break;
default:
break;
}
return(ret);
}
/// <summary>
/// Creates a FileContentResult object by using Report Viewer Web Control.
/// </summary>
/// <param name="controller">The Controller instance that this method extends.</param>
/// <param name="reportFormat">Report Viewer Web Control supported format (Excel, Word, PDF or Image)</param>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="mode">Report processing mode: remote or local.</param>
/// <param name="localReportDataSources">Local report data sources</param>
/// <returns>The file-content result object.</returns>
public static FileStreamResult Report(
this Controller controller,
ReportFormat reportFormat,
IReportLoader reportLoader,
object reportParameters,
ProcessingMode mode,
IEnumerable<IDataSource> reportDataSources = null,
IEnumerable<ISubReportDataSource> subReportDataSources = null)
{
var reportRunner = new ReportRunner(
reportFormat,
reportLoader,
HtmlHelper.AnonymousObjectToHtmlAttributes(reportParameters),
mode,
reportDataSources,
subReportDataSources);
return reportRunner.Run();
}
/// <summary>
/// Iterates through each pixel and processes the data into a map of the resulting frequency and amplitude for each pixel
/// </summary>
/// <param name="mode"></param>
/// <returns>2D array of audio data that matches the image pixels</returns>
public AudioData[,] Process(ProcessingMode mode)
{
_progressBar.Value = 0;
_progressBar.Maximum = ImageWidth;
var data = new AudioData[ImageWidth, ImageHeight];
for (int i = 0; i < ImageWidth; i++)
{
for (int j = 0; j < ImageHeight; j++)
{
//Data from each pixel mapped to output
data[i, j] = ProcessPixel(i, j, mode);
}
_progressBar.Value++;
}
return(data);
}
private bool AllJobChunksCompleted(string jobId, ProcessingMode mode)
{
Logger.Log.Instance.Info(string.Format("CacheJobChunkRegistrator. Check for competion of phase {1}. JobId '{0}'",
jobId, mode));
var sumKey = GetJobSummeryKey(jobId);
var jobSplitDetails = AzureClient.Instance.CacheClient[sumKey] as JobSplitDetails;
var completedStatus = mode == ProcessingMode.Map ? ChunkStatus.MapCompleted : ChunkStatus.ReduceCompleted;
foreach (var chunkId in jobSplitDetails.JobChunkIds)
{
var chunkKey = GetJobChunkKey(new JobChunkUid()
{
JobId = jobId, ChunkId = chunkId
}, mode);
var chunkStatus = AzureClient.Instance.CacheClient[chunkKey] as JobChunkStatus;
Logger.Log.Instance.Info(string.Format(" ==> Chunk {0}. Status: {1}",
chunkId, chunkStatus.Status));
if (chunkStatus.Status != completedStatus)
{
Logger.Log.Instance.Info(string.Format(" ==> Not completed yet"));
return(false);
}
}
Logger.Log.Instance.Info(string.Format(" ==> Phase completed. Clear cache"));
// Clear cache
foreach (var chunkId in jobSplitDetails.JobChunkIds)
{
var chunkKey = GetJobChunkKey(new JobChunkUid()
{
JobId = jobId, ChunkId = chunkId
}, mode);
AzureClient.Instance.CacheClient.Remove(chunkKey);
Logger.Log.Instance.Info(string.Format(" ==> Clear cache for chunk {0}", chunkId));
}
AzureClient.Instance.CacheClient.Remove(sumKey);
Logger.Log.Instance.Info(string.Format(" ==> Clear cache for sum of job {0}", jobId));
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="QueuedBackgroundWorker"/> class.
/// </summary>
public QueuedBackgroundWorker()
{
lockObject = new object();
stopping = false;
started = false;
disposed = false;
// Threads
threadCount = 5;
CreateThreads();
// Work items
processingMode = ProcessingMode.FIFO;
priorityQueues = 5;
BuildWorkQueue();
cancelledItems = new Dictionary<object, bool>();
// The loader complete callback
workCompletedCallback = new SendOrPostCallback(this.RunWorkerCompletedCallback);
}
/// <summary>
/// Initializes a new instance of the <see cref="QueuedBackgroundWorker"/> class.
/// </summary>
public QueuedBackgroundWorker()
{
lockObject = new object();
stopping = false;
started = false;
disposed = false;
// Threads
threadCount = 5;
CreateThreads();
// Work items
processingMode = ProcessingMode.FIFO;
priorityQueues = 5;
BuildWorkQueue();
cancelledItems = new Dictionary <object, bool>();
// The loader complete callback
workCompletedCallback = new SendOrPostCallback(this.RunWorkerCompletedCallback);
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
string reportServerUrl,
string username,
string password,
IDictionary<string, object> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null,
string filename = null)
: this(reportFormat,
reportPath,
reportServerUrl,
username,
password,
reportParameters?.ToList(),
mode,
localReportDataSources,
filename)
{
}
public void SetMode(ProcessingMode mode)
{
_clients.All.SetMode(mode);
}
public ReportRunner(
ReportFormat reportFormat,
string reportPath,
string reportServerUrl,
string username,
string password,
IEnumerable<KeyValuePair<string, object>> reportParameters,
ProcessingMode mode = ProcessingMode.Remote,
IDictionary<string, DataTable> localReportDataSources = null,
string filename = null)
{
_viewerParameters = new ReportViewerParameters
{
ReportServerUrl = _config.ReportServerUrl,
Username = _config.Username,
Password = _config.Password,
IsReportRunnerExecution = true
};
ReportFormat = reportFormat;
_filename = filename;
_viewerParameters.ProcessingMode = mode;
if (mode == ProcessingMode.Local && localReportDataSources != null)
{
_viewerParameters.LocalReportDataSources = localReportDataSources;
}
_viewerParameters.ReportPath = reportPath;
_viewerParameters.ReportServerUrl = reportServerUrl ?? _viewerParameters.ReportServerUrl;
if (username != null || password != null)
{
_viewerParameters.Username = username;
_viewerParameters.Password = password;
}
ParseParameters(reportParameters);
}
private void AddChunkToCache(JobChunkUid chunkUid, ProcessingMode mode)
{
var chunkKey = GetJobChunkKey(chunkUid, mode);
var chunkStatus = new JobChunkStatus()
{
LastUpdate = DateTime.Now,
Status = mode == ProcessingMode.Map ? ChunkStatus.NewMap : ChunkStatus.NewReduce
};
chunkStatus.ChunkUid.JobId = chunkUid.JobId;
chunkStatus.ChunkUid.ChunkId = chunkUid.ChunkId;
AzureClient.Instance.CacheClient.Add(chunkKey, chunkStatus);
}
private void Add(string[] names, ProcessingMode mode, params Attribute[] attributes)
{
Element result = new Element(names, mode, attributes);
Add(result);
}
public DuplicateFilter(string fieldName, KeepMode keepMode, ProcessingMode processingMode)
{
this.fieldName = fieldName;
this.keepMode = keepMode;
this.processingMode = processingMode;
}
private string GetJobChunkKey(JobChunkUid chunkUid, ProcessingMode mode)
{
return string.Format("{3}_{0}{1}_{2}", JobChunkKeyPrefix, chunkUid.JobId, chunkUid.ChunkId, mode);
}
private void UpdateChunkStatusInCache(JobChunkUid chunkUid, ChunkStatus status, ProcessingMode mode)
{
var chunkKey = GetJobChunkKey(chunkUid, mode);
var chunkStatus = AzureClient.Instance.CacheClient.Get(chunkKey) as JobChunkStatus;
if (chunkStatus == null)
throw new UnknownChunkException("Unrestered chunk") { ChunkUid = chunkUid };
chunkStatus.Status = status;
chunkStatus.LastUpdate = DateTime.Now;
AzureClient.Instance.CacheClient.Add(chunkKey, chunkStatus);
}
public static string GetString(ProcessingMode mode)
{
string ret = "";
switch (mode)
{
case ProcessingMode.Activity:
ret = "appointment_only";
break;
case ProcessingMode.Inventory:
ret = "inventory_only";
break;
default:
break;
}
return ret;
}
private void Add(string names, ProcessingMode mode)
{
Add(names.Split('/'), mode, new Attribute[0]);
}
private bool AllJobChunksCompleted(string jobId, ProcessingMode mode)
{
Logger.Log.Instance.Info(string.Format("CacheJobChunkRegistrator. Check for competion of phase {1}. JobId '{0}'",
jobId, mode));
var sumKey = GetJobSummeryKey(jobId);
var jobSplitDetails = AzureClient.Instance.CacheClient[sumKey] as JobSplitDetails;
var completedStatus = mode == ProcessingMode.Map ? ChunkStatus.MapCompleted : ChunkStatus.ReduceCompleted;
foreach (var chunkId in jobSplitDetails.JobChunkIds)
{
var chunkKey = GetJobChunkKey(new JobChunkUid() { JobId = jobId, ChunkId = chunkId }, mode);
var chunkStatus = AzureClient.Instance.CacheClient[chunkKey] as JobChunkStatus;
Logger.Log.Instance.Info(string.Format(" ==> Chunk {0}. Status: {1}",
chunkId, chunkStatus.Status));
if (chunkStatus.Status != completedStatus)
{
Logger.Log.Instance.Info(string.Format(" ==> Not completed yet"));
return false;
}
}
Logger.Log.Instance.Info(string.Format(" ==> Phase completed. Clear cache"));
// Clear cache
foreach (var chunkId in jobSplitDetails.JobChunkIds)
{
var chunkKey = GetJobChunkKey(new JobChunkUid() { JobId = jobId, ChunkId = chunkId }, mode);
AzureClient.Instance.CacheClient.Remove(chunkKey);
Logger.Log.Instance.Info(string.Format(" ==> Clear cache for chunk {0}", chunkId));
}
AzureClient.Instance.CacheClient.Remove(sumKey);
Logger.Log.Instance.Info(string.Format(" ==> Clear cache for sum of job {0}", jobId));
return true;
}
/// <summary>
/// Sets ReportViewer report processing mode.
/// </summary>
/// <param name="mode">Processing Mode (Local or Remote).</param>
/// <returns>An instance of MvcViewerOptions class.</returns>
public IMvcReportViewerOptions ProcessingMode(ProcessingMode mode)
{
_processingMode = mode;
return this;
}
//--- Constructors ---
public Element(string[] names, ProcessingMode mode, params Attribute[] attributes)
{
if(ArrayUtil.IsNullOrEmpty(names)) {
throw new ArgumentNullException("names");
}
this.Names = names;
this.Mode = mode;
foreach(Attribute attribute in attributes) {
this.Attributes[attribute.Name] = attribute;
}
}
public void SetMode(ProcessingMode mode)
{
Camera.SetMode(mode);
Browsers.Toast($"Changing mode to {mode}");
}
/// <summary>
/// Creates an instance of MvcReportViewerIframe class.
/// </summary>
/// <param name="reportPath">The path to the report on the server.</param>
/// <param name="reportServerUrl">The URL for the report server.</param>
/// <param name="username">The report server username.</param>
/// <param name="password">The report server password.</param>
/// <param name="reportParameters">The report parameter properties for the report.</param>
/// <param name="controlSettings">The Report Viewer control's UI settings.</param>
/// <param name="htmlAttributes">An object that contains the HTML attributes to set for the element.</param>
/// <param name="method">Method for sending parameters to the iframe, either GET or POST.</param>
public MvcReportViewerIframe(
IReportLoader reportLoader,
IDictionary<string, object> reportParameters,
ControlSettings controlSettings,
IDictionary<string, object> htmlAttributes,
FormMethod method)
{
var javaScriptApi = ConfigurationManager.AppSettings[WebConfigSettings.JavaScriptApi];
if (string.IsNullOrEmpty(javaScriptApi))
{
throw new MvcReportViewerException("MvcReportViewer.js location is not found. Make sure you have MvcReportViewer.AspxViewerJavaScript in your Web.config.");
}
_reportLoader = reportLoader;
_processingMode = Microsoft.Reporting.WebForms.ProcessingMode.Local;
_controlSettings = controlSettings;
_reportParameters = reportParameters != null ? reportParameters.ToList() : null;
_htmlAttributes = htmlAttributes;
_method = method;
_aspxViewer = ConfigurationManager.AppSettings[WebConfigSettings.AspxViewer];
if (string.IsNullOrEmpty(_aspxViewer))
{
throw new MvcReportViewerException("ASP.NET Web Forms viewer is not set. Make sure you have MvcReportViewer.AspxViewer in your Web.config.");
}
_aspxViewer = _aspxViewer.Trim();
if (_aspxViewer.StartsWith("~"))
{
_aspxViewer = VirtualPathUtility.ToAbsolute(_aspxViewer);
}
var encryptParametesConfig = ConfigurationManager.AppSettings[WebConfigSettings.EncryptParameters];
if (!bool.TryParse(encryptParametesConfig, out _encryptParameters))
{
_encryptParameters = false;
}
ControlId = Guid.NewGuid();
}
