public void Publish(DeployConfigurationModel deployConfiguration, TelemetryWrapper telemetry, string singleResourceName, string project, string projectPath, string basePath)
{
try
{
Action <string> reportAction = (m) => { ReportProgress?.Invoke(this, m); };
var context = new XrmService(deployConfiguration.DynamicsSettings, deployConfiguration.Solution, telemetry, reportAction);
var sourceControl = new VersioningService(projectPath, basePath, deployConfiguration.Branch, reportAction, telemetry);
var sourceControlResult = sourceControl.QueryLocalRepository();
// Must resolve conflicts or something went wrong with TFS interaction
if (!sourceControlResult.Continue && sourceControlResult.Changes == null)
{
return;
}
var changeList = sourceControlResult.Changes;
if (!string.IsNullOrEmpty(singleResourceName))
{
var filteredChangeList = sourceControlResult.Changes.Where(x => x.FileName.Equals(singleResourceName)).ToArray();
changeList = filteredChangeList;
}
PublishImpl(context, sourceControl, deployConfiguration, telemetry, changeList, project);
}
catch (Exception exception)
{
ReportProgress?.Invoke(this, $"[ERROR] => {exception.Message}\n");
if (!(exception is ToolkitException))
{
telemetry.TrackExceptionWithCustomMetrics(exception);
}
}
}
public async Task <double> TrainNetwork(double[][] inputs, double[][] outputs, double learningrate, double momentum, int iterations, double minerror)
{
try
{
_run = true;
SetMomentum(momentum);
for (_iteration = 0; _iteration < iterations; _iteration++)
{
double error = 0;
for (int s = 0; s < inputs.Length; s++)
{
if (!_run)
{
return(_error);
}
error += await TrainSample(inputs[s], outputs[s], learningrate);
}
_error = error / inputs.Length;
ReportProgress?.Invoke(this, EventArgs.Empty);
if (_error < minerror)
{
break;
}
}
return(_error);
}
finally
{
ReportProgress = null;
}
}
public async Task LoadModules(string path, string filter)
{
await Task.Run(() =>
{
try
{
var curplug = 0;
var pluginFiles = System.IO.Directory.GetFiles(path, filter, System.IO.SearchOption.TopDirectoryOnly);
foreach (var filename in pluginFiles)
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++curplug, pluginFiles.Length, "Loading plugins...", OperationTag.Active));
var types = AssemblyLoader.LoadClassesFromFile <IInstallerModule>(System.IO.Path.GetFullPath(filename)).Where(t => t != null);
if (types.Any())
{
PluginLoaded?.Invoke(this, new PluginLoadedEventArgs(types));
}
}
}
catch (Exception ex)
{
ErrorOccured?.Invoke(this, new ErrorOccuredEventArgs(ex, "Error loading modules"));
}
finally
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(0, StatusName.Idle, OperationTag.None));
LoadingFinished?.Invoke(this, EventArgs.Empty);
}
});
}
public static Bitmap ToGrayscale(
Bitmap source,
CancellationToken token,
ReportProgress onProgress = null)
{
Bitmap result = new Bitmap(source);
for (int y = 0; y < source.Height; y++)
{
int currentProgress = (int)(((double)y / source.Height) * 100);
onProgress?.Invoke(currentProgress);
for (int x = 0; x < source.Width; x++)
{
if (token.IsCancellationRequested)
{
return(result);
}
Color c = source.GetPixel(x, y);
var gray = (int)
(c.R * 0.299 +
c.G * 0.587 +
c.B * 0.114);
var grayColor = Color.FromArgb(gray, gray, gray);
result.SetPixel(x, y, grayColor);
}
}
return(result);
}
private async void GetData(CancellationToken cancelationToken)
{
try
{
m_Source.MessageRecieved += ProcessMessage;
int count = 0;
if (!m_Source.SupportProgress)
{
ProgressArgs args = new ProgressArgs("This DataSource does not support Progress updates.", false, (int)50);
ReportProgress?.Invoke(this, args);
}
await foreach (IFrame frame in m_Source.GetData(m_sourceSignals, m_start, m_end))
{
frame.Timestamp = Ticks.AlignToMicrosecondDistribution(frame.Timestamp, m_commonFrameRate);
await m_sourceQueue.Writer.WriteAsync(frame, cancelationToken);
count++;
if (count % 1000 == 0 && m_Source.SupportProgress)
{
ReportDatasourceProgress(m_Source.GetProgress());
}
}
}
finally
{
MessageRecieved?.Invoke(this, new MessageArgs("Finished Loading Data from DataSource", MessageArgs.MessageLevel.Info));
m_sourceQueue.Writer.Complete();
}
}
public async Task LoadProject(string filename)
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(StatusName.MarqueeProgressBarStyle, "Loading project...", OperationTag.Active | OperationTag.Cancellable));
var stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
Project proj = null;
await Task.Run(() => proj = ConfigurationBase.Deserialize <Project>(System.IO.File.ReadAllText(filename), new PluginSerializationBinder()));
proj.Name = System.IO.Path.GetFileName(filename);
stopwatch.Stop();
logger.Debug($"Project loaded in {stopwatch.Elapsed}.");
var curmod = 0;
var loadAwareModules = proj.Modules.OfType <ISaveLoadAware>();
foreach (var module in loadAwareModules)
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++curmod, loadAwareModules.Count(), "Loading project...", OperationTag.Active | OperationTag.Cancellable));
module.AfterLoad();
}
proj.Modules.ToList().ForEach(m => m.StatusChanged += Module_StatusChanged);
Project = proj;
IsModified = false;
await RefreshModuleStatus();
}
private void SendProgress(string message, int?processedCount = null)
{
var progress = new ReportProgress
{
Message = message,
WorkItemsProcessed = processedCount
};
this.broadcastService.ReportProgress(progress);
}
private async Task <TfsInfo> ProcessWorkItemRevisions(WorkItemReference workItemRef)
{
var revisions = await this.workItemClient.GetRevisionsAsync(
workItemRef.Id,
expand : WorkItemExpand.Fields);
string lastState = null;
var revs = new WorkItemRevisionBuilder();
foreach (var workItemRev in revisions)
{
var state = workItemRev.State();
if (state != null && lastState != state)
{
lastState = state;
await ProcessWorkItemRevision(workItemRev, revs);
}
}
if (revs.States.Count > 1)
{
var sbTemp = new StringBuilder();
for (int i = 0; i < revs.States.Count; i++)
{
sbTemp.Append(revs.States[i].Summary);
if (i + 1 < revs.States.Count)
{
sbTemp.AppendLine();
}
revs.TfsInfo.Transitions = sbTemp.ToString().Trim();
}
revs.TfsInfo.TransitionCount = revs.States.Count;
}
lock (this.lockObject)
{
this.processedCount++;
var progress = new ReportProgress
{
Message = $"{revs.TfsInfo.Title}",
WorkItemsProcessed = this.processedCount,
TotalCount = this.totalCount
};
this.broadcastService.ReportProgress(progress);
}
return(revs.TfsInfo);
}
internal PlayGamesAchievement(ReportProgress progressCallback)
{
mId = string.Empty;
mLastModifiedTime = new DateTime(1970, 1, 1, 0, 0, 0, 0);
mTitle = string.Empty;
mRevealedImageUrl = string.Empty;
mUnlockedImageUrl = string.Empty;
mDescription = string.Empty;
base._002Ector();
mProgressCallback = progressCallback;
}
void ReadStdErr()
{
var buffer = new char[1];
ReportProgress progress = new ReportProgress(AVRdudeWorker.ReportProgress);
while (process.StandardError.Read(buffer, 0, 1) > 0 && AVRdudeWorker.IsBusy)
{
try { form1.Invoke(progress, new object[] { 0, new string(buffer) }); }
catch { Errors.Add("Program output truncated!"); }
}
}
public async Task RefreshModuleStatus(IEnumerable <IInstallerModule> pickModules = null, bool throwIfCancelled = false)
{
await Task.Run(() =>
{
var options = new ParallelOptions()
{
//CancellationToken = GetCancellationToken()
};
try
{
IEnumerable <IInstallerModule> modules;
if (pickModules != null)
{
modules = pickModules;
}
else
{
modules = Project.ModuleList;
}
var currow = 0;
Parallel.ForEach(modules, options, module =>
{
Interlocked.Add(ref currow, 1);
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++currow, modules.Count(), "Refreshing list...", OperationTag.Active));
try
{
options.CancellationToken.ThrowIfCancellationRequested();
//logger.Info($"Module {module.Name} - Checking status...");
if (module != null && module.Status != InstallerModuleStatus.Refreshing)
{
module.CheckStatus();
}
}
catch (Exception ex)
{
logger.Error($"Error checking status of module {module.FriendlyName}.", ex);
}
});
}
catch (OperationCanceledException)
{
if (throwIfCancelled)
{
throw;
}
}
finally
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(0, StatusName.Idle, OperationTag.None));
}
});
}
/// <summary>
/// 建構式，將Validator的Validate方法參數傳入
/// </summary>
/// <param name="ValidatorPairs"></param>
/// <param name="OutputFile"></param>
/// <param name="OutputOptions"></param>
public OutputBuilder(IEnumerable<ValidatePair> ValidatorPairs,
string OutputFile,
OutputOptions OutputOptions,
ReportProgress ReportProgress)
{
//初始化從Validator傳來的參數
mValidatorPairs = ValidatorPairs.ToList();
mOutputFile = OutputFile;
//預設讀取第一個Excel
mSheet = new SheetHelper(mValidatorPairs[0].DataFile, mValidatorPairs[0].DataSheet);
mCurrentPair = mValidatorPairs[0];
mReportProgress = ReportProgress;
}
private void PrefetchingTask_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
if (Items.Count > 0)
{
if (ReportProgressSlim is Action)
{
ReportProgressSlim.Invoke(async: false);
}
else if (ReportProgress is Action <double, string, TaskStatus> )
{
ReportProgress.Invoke(Percentage, Comments, State);
}
}
}
private void ReportDatasourceProgress(double dataSourceProgress)
{
double totalProgress = dataSourceProgress * 0.5D;
double wFactor = 1.0D / (double)m_writers.Count() * 0.5D;
foreach (KeyValuePair <string, SignalWritter> writer in m_writers)
{
totalProgress += dataSourceProgress * wFactor * ((-1.0D / 10000.0D) * (double)writer.Value.Backlog + 1.0D);
}
ProgressArgs args = new ProgressArgs("Loading Data.", false, (int)totalProgress);
ReportProgress?.Invoke(this, args);
}
protected void LoadParameterizedStreamContent(string parameter, string format)
{
long end = Environment.TickCount;
try
{
using (Stream DerivedFileStream = ObtainStream(parameter))
{
ReportProgress ReportProgress = delegate()
{
if (Environment.TickCount - end > 25)
{
ConsoleUtils.ProgressBarShow((uint)DerivedFileStream.Position, (uint)DerivedFileStream.Length, this.Notification);
end = Environment.TickCount;
}
};
ConsoleUtils.ProgressBarShow((uint)DerivedFileStream.Position, (uint)DerivedFileStream.Length, this.Notification);
switch (format.ToLowerInvariant())
{
case "text/csv":
ParseAsCsvStream(DerivedFileStream, ReportProgress); break;
case "text/xml":
ParseAsXmlStream(DerivedFileStream, ReportProgress); break;
default:
if (!ParseAsOtherStream(DerivedFileStream, ReportProgress, format))
{
HostContext.AddUnhandeldException(new Exception(string.Format("Unsupported fileformat: {0}", this)));
}
break;
}
ConsoleUtils.ProgressBarHide(this.ReadyState);
}
}
catch (IOException e)
{
//Trace.TraceError("Error opening: {0}", Filename);
e.Source += this.ToString();
HostContext.AddUnhandeldException(e);
}
catch (Exception e)
{
//Trace.TraceError("Unhandeld exception {0}", e);
e.Source += this.ToString();
HostContext.AddUnhandeldException(new SystemException(string.Format("Unhandeld exception occured on {0} {1}", parameter, format), e));
}
}
private async void Progress_ProgressChanged(object sender, ReportProgress e)
{
if (!Dispatcher.CheckAccess())
{
await Dispatcher.BeginInvoke((Action)(() =>
{
UpdateProgress(e.Percent, e.Progress, e.SiteReady);
}));
}
else
{
UpdateProgress(e.Percent, e.Progress, e.SiteReady);
}
}
private int NotifyProgress(long currentBytes, long totalBytes, int skip)
{
skip++;
if (skip >= 10)
{
skip = 0;
int percent = (int)((currentBytes * 100) / totalBytes);
if (percent > _lastProgress)
{
_lastProgress = percent;
ReportProgress?.Invoke(_lastProgress);
}
}
return(skip);
}
public WaitingDialog(Func <IProgress <Tuple <string, int> >, CancellationToken, object> worker_func, Func <string, string> format_label)
{
if (format_label == null)
{
format_label = s => String.Format("Currently Processing {0}. Please Wait.", s);
}
m_cancellation = new CancellationTokenSource();
CancellationToken token = m_cancellation.Token;
m_progress = new ReportProgress(SetProgress, token, format_label);
m_worker = new BackgroundWorker();
m_worker.DoWork += (sender, e) => Result = worker_func(m_progress, token);
m_worker.RunWorkerCompleted += RunWorkerCompletedCallback;
InitializeComponent();
SetProgress(String.Empty, 0);
}
public void Execute(Action action)
{
string key = Guid.NewGuid().ToString();
int res = RmStartSession(out IntPtr handle, 0, key);
if (res == 0)
{
ReportProgress?.Invoke($"Restart Manager session created with ID {key}");
RM_UNIQUE_PROCESS[] processes = GetProcesses("explorer");
res = RmRegisterResources(
handle,
0, null,
(uint)processes.Length, processes,
0, null
);
if (res == 0)
{
ReportProgress?.Invoke("Successfully registered resources.");
res = RmShutdown(handle, RM_SHUTDOWN_TYPE.RmForceShutdown, (percent) => ReportPercentage?.Invoke(percent));
if (res == 0)
{
ReportProgress?.Invoke("Applications stopped successfully.");
action();
res = RmRestart(handle, 0, (percent) => ReportPercentage?.Invoke(percent));
if (res == 0)
{
ReportProgress?.Invoke("Applications restarted successfully.");
}
}
}
res = RmEndSession(handle);
if (res == 0)
{
ReportProgress?.Invoke("Restart Manager session ended.");
}
}
}
public WebDownload(string url, ReportProgress progress = null)
{
using(WebClient client = new WebClient())
{
var req = WebRequest.CreateHttp(url);
using (var response = req.GetResponse())
{
var fileSize = response.ContentLength;
FileName = response.ResponseUri.Segments.Last();
var part = new byte[1024 * 1024];
using(var stream = response.GetResponseStream())
using(var ms = new MemoryStream())
{
//stream.CopyTo(ms)
int len;
do
{
len = stream.Read(part, 0, part.Length);
ms.Write(part, 0, len);
System.Diagnostics.Debug.WriteLine(len);
if (progress != null)
{
if (fileSize > 0)
{
long percentage = ms.Length * 100;
percentage /= fileSize;
progress((int)percentage);
}
}
} while (len > 0);
Content = ms.ToArray();
}
}
}
}
public void Sort(ref Color[] color)
{
for (int i = 0; i < color.Length; i++)
{
for (int j = 0; j < color.Length - i - 1; j++)
{
int A_Hue = (int)Math.Round(color[j].GetHue());
int A1_Hue = (int)Math.Round(color[j + 1].GetHue());
if (A_Hue > A1_Hue)
{
Swap(color, j, j + 1);
}
ReportProgress?.Invoke();
}
Thread.Sleep((int)Utility.SleepTime);
}
}
private void CopyRun()
{
CopyQueue = new Queue <Uri>();
CopyQueue.OnItemAdded += () =>
{
ReportProgress?.Invoke(FileAction.Copy, CopyQueue.Count);
Uri nextFile;
while ((nextFile = CopyQueue.GetNext()) != null)
{
List <Uri> outputs = workspace.GetSlavesPaths(nextFile);
foreach (var file in outputs)
{
File.Copy(nextFile.AbsolutePath, file.AbsolutePath, true);
}
ReportProgress?.Invoke(FileAction.Copy, CopyQueue.Count);
}
};
}
public SwitcherControl(System.Windows.Threading.Dispatcher dispatcher, ReportView reportProgrammView, ReportProgress progress)
{
m_switcherMonitor = new SwitcherMonitor();
m_switcherMonitor.SwitcherDisconnected += new SwitcherEventHandler((s, a) => dispatcher.Invoke((Action)(() => SwitcherDisconnected())));
m_mixEffectBlockMonitor = new MixEffectBlockMonitor();
m_mixEffectBlockMonitor.TransitionPositionChanged += new SwitcherEventHandler((s, a) => dispatcher.Invoke((Action)(() => UpdateSliderPosition())));
m_mixEffectBlockMonitor.InTransitionChanged += new SwitcherEventHandler((s, a) => dispatcher.Invoke((Action)(() => OnInTransitionChanged())));
m_switcherDiscovery = new CBMDSwitcherDiscovery();
if (m_switcherDiscovery == null)
{
MessageBox.Show("Could not create Switcher Discovery Instance.\nATEM Switcher Software may not be installed.", "Error");
Environment.Exit(1);
}
SwitcherDisconnected(); // start with switcher disconnected
_reportProgrammView = reportProgrammView;
_progress = progress;
}
private void Work(object ithread)
{
ReportProgress?.Invoke(0);
while (true)
{
int x;
lock (locker) {
if (toBeProcessed.Count == 0)
{
break;
}
x = toBeProcessed.Pop();
}
calculation(x, (int)ithread);
lock (locker) {
tasksDone++;
ReportProgress?.Invoke(tasksDone / (double)nTasks);
}
}
}
/// <summary>
/// 进度条
/// </summary>
/// <param name="progress"></param>
private void ReportProgressHandler(double progress)
{
if (this.progressBar.InvokeRequired)
{
ReportProgress d = new ReportProgress(ReportProgressHandler);
this.progressBar.Invoke(d, new object[] { progress });
}
else
{
int value = (int)((progress + 1) * 100 / (this.grabFrames.MediaInfo.Duration * this.grabFrames.MediaInfo.FPS));
if (value >= 100)
{
this.progressBar.Value = 0;
this.progressBar.Visible = false;
SetResult(true);
this.btnSelect.Enabled = true;
}
this.progressBar.Value = value;
}
}
private void PrefetchingTask_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (Items.Count > 0)
{
if (State == TaskStatus.Faulted || State == TaskStatus.Canceled)
{
if (ReportProgressSlim is Action)
{
ReportProgressSlim.Invoke(async: false);
}
else if (ReportProgress is Action <double, string, TaskStatus> )
{
ReportProgress.Invoke(Percentage, Comments, State);
}
}
//Application.Current.MergeToSystemPrefetchedList(PrefetchedList);
}
if (CanPrefetching is SemaphoreSlim && CanPrefetching.CurrentCount < 1)
{
CanPrefetching.Release();
}
}
private void PublishImpl(XrmService context, VersioningService gitvc, DeployConfigurationModel deployConfiguration, TelemetryWrapper telemetry, RawChanges[] changes, string project)
{
try
{
ChangeManagerService container = new ChangeManagerService(changes, deployConfiguration.Prefix, context);
telemetry.TrackCustomEventWithCustomMetrics("Deploy Started", new MetricData("Project Name", project));
if (container.WebResources.Count > 0)
{
ReportProgress?.Invoke(this, $"[DYNAMICS] => Found {container.WebResources.Count} Web Resource.");
ReportProgress?.Invoke(this, $"[DYNAMICS] => '{deployConfiguration.Prefix}' used as base path.");
ReportProgress?.Invoke(this, $"[DYNAMICS] => Fetching '{deployConfiguration.Solution}' solution from CRM.");
container.EnsureContinue(deployConfiguration.Solution, deployConfiguration.Prefix);
ReportProgress?.Invoke(this, $"[DYNAMICS] => Publishing changes to the CRM.");
var faultedFlushResult = context.Flush(container.BuildRequestList(deployConfiguration.Solution));
if (!faultedFlushResult && deployConfiguration.CheckInEnabled)
{
ReportProgress?.Invoke(this, $"[AZOPS] => Commit & Push in progress.");
gitvc.CommitAndPush(deployConfiguration.Password);
}
ReportProgress?.Invoke(this, $"[AZOPS] => Publish completed.");
}
telemetry.TrackCustomEventWithCustomMetrics("Deploy Finished", new MetricData("Project Name", project));
}
catch (Exception exception)
{
ReportProgress?.Invoke(this, $"[ERROR] => {exception.Message}\n");
if (!(exception is ToolkitException))
{
telemetry.TrackExceptionWithCustomMetrics(exception);
}
}
}
public void SaveProject(string filename)
{
var saveAwareModules = Project.Modules.OfType <ISaveLoadAware>();
var curmod = 0;
var allmods = saveAwareModules.Count() * 2;
foreach (var module in saveAwareModules)
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++curmod, allmods, "Saving project..", OperationTag.Active | OperationTag.Cancellable));
module.BeforeSave();
}
System.IO.File.WriteAllText(filename, Project.Serialize());
foreach (var module in Project.Modules.OfType <ISaveLoadAware>())
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++curmod, allmods, "Saving project...", OperationTag.Active | OperationTag.Cancellable));
module.AfterSave();
}
Project.Name = System.IO.Path.GetFileName(filename);
NotifyProjectChange();
IsModified = false;
}
private string StartPanoCaptureProcessor(IEnumerable <string> inputFiles, ReportProgress argProgress, bool crop)
{
var files = inputFiles.Where(f => f != null && (f.EndsWith(".jpeg") || f.EndsWith(".jpg") || f.EndsWith(".tif") || f.EndsWith(".tiff")));
if (!files.Any())
{
return(null);
}
var outputFolder = Path.GetDirectoryName(inputFiles.First());
var outputFileName = files.Last().Split('.').First() + "-pano.tif";
var outputFile = Path.Combine(outputFolder, outputFileName);
var builtFile = new PanoramaBuilder(outputFile, inputFiles.ToArray())
.SetHuginBinPath(_settings.HuginBinPath)
.SetTempDir(outputFolder)
.SetLogDir(_logDir)
.ConfigureProgressUpdater((update) => argProgress(update.StepNumber, update.StepTotal, update.StepText))
.Build()
.GetGeneratedFile();
return(builtFile);
}
private void ReportProgressHandler(double progress)
{
if (this.progressPanel1.ProgressBar.InvokeRequired)
{
ReportProgress d = new ReportProgress(ReportProgressHandler);
this.progressPanel1.ProgressBar.Invoke(d, new object[] { progress });
}
else
{
int value = (int)(100 * (progress + 1) / this._grabFrames.MediaInfo.Duration);
if (value >= 100)
{
value = 100;
this.progressPanel1.IsVisible(false);
this.snapShots.LoadFrames(_grabFrames.Frames);
this.btnSave.Enabled = true;
this.btnVideoPlay.Enabled = true;
this.btnVideoStop.Enabled = true;
this.btnVideoSave.Enabled = true;
InitilizeFps();
}
this.progressPanel1.ProgressBar.Value = value;
}
}
public static void AddItem(NewItem param, ReportProgress progressReport)
{
// 0%
ReportProgress(progressReport, 0);
string[] sc = {";", " ", ","};
string[] tags = param.Tags.Split(sc, StringSplitOptions.RemoveEmptyEntries);
// check uri
bool isUriLocal = IsUriLocal(param.Uri);
/*
* Local URI
* [keep local] store to database
* [not keep] only link
*
* Web file
* [keep local] store to database
* [not keep] only link
*/
var item = new DocItem()
{
Uri = param.Uri,
Name = param.Name,
Rating = 3
};
// Download file
// 90%
if (isUriLocal)
{
// local filesystem
item.FileName = Path.GetFileName(param.Uri);
item.HashCode = HashCalc.GetHash(param.Uri);
}
else
{
var download = new WebDownload(param.Uri, (int p, string d) =>
{
int percentage = p * 90;
percentage /= 100;
ReportProgress(progressReport, percentage);
});
item.FileName = download.FileName;
item.HashCode = HashCalc.GetHash(download.Content);
}
ReportProgress(progressReport, 90);
// add DB record
// 100%
using (var db = new AppDataBase())
using(var transaction = db.Database.BeginTransaction())
{
// try to select existing tags
//var registeredTags = db.Tags.Select(x => x.Name).Intersect(tags, StringComparer.InvariantCultureIgnoreCase).ToArray();
var registeredTags = from i in db.Tags
where tags.Contains(i.Name.ToLower())
select i;
// save new tags
var newTags = tags.Except(registeredTags.Select(x => x.Name), StringComparer.InvariantCultureIgnoreCase);
item.Tags = new List<Tag>();
// add link to existing tags
foreach(var i in registeredTags)
{
item.Tags.Add(i);
}
// add new tags and link with document
foreach(var i in newTags)
{
var newTagRecord = db.Tags.Add(new Tag()
{
Name = i
});
item.Tags.Add(newTagRecord);
}
// save tags
db.SaveChanges();
// add item
db.Items.Add(item);
// save item
db.SaveChanges();
transaction.Commit();
}
}
private static void ReportProgress(ReportProgress progressReport, int percentage)
{
if (progressReport != null)
{
progressReport(percentage);
}
}
protected override void ParseAsXmlStream(Stream stream, ReportProgress ProgressReport)
{
using (XmlTextReader reader = new XmlTextReader(stream))
{
ItemInfo item = new ItemInfo();
string value = null;
while (reader.Read())
{
ProgressReport.Invoke();
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.Name.ToUpperInvariant())
{
case "ROW": item = new ItemInfo(); continue;
default: value = null; break;
}
break;
case XmlNodeType.Text:
value = reader.Value;
break;
case XmlNodeType.EndElement:
switch (reader.Name.ToUpperInvariant())
{
case "ID": item.item = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "ADDITION": item.addition = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "PART": item.part = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "TYPE": item.type = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "PRICE": item.price = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "TRADE": item.trade = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "DROP": item.drop = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "NAME": item.name = value; break;
case "QUEST": item.quest = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_CLV": item.req_clvl = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_MALE": item.req_male = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_FEMALE": item.req_female = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_NORMAN": item.req_norman = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_ELLR": item.req_ellr = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_DIMAGO": item.req_dimago = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_STR": item.req_str = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_DEX": item.req_dex = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_INT": item.req_int = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_CON": item.req_con = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_LUC": item.req_luc = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "MAX_STACK": item.max_stack = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "MAX_DUR": item.max_durability = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "SKILL": item.skill = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "OPTION_ID": item.option_id = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "CATEGORIE": item.categorie = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "JOBREQUIREMENT":
string[] values = value.Split(',');
item.JobRequirement = new byte[]
{
byte.Parse(values[0], NumberFormatInfo.InvariantInfo), //NOVICE
byte.Parse(values[1], NumberFormatInfo.InvariantInfo), //SWORDSMAN
byte.Parse(values[3], NumberFormatInfo.InvariantInfo), //RECRUIT
byte.Parse(values[2], NumberFormatInfo.InvariantInfo), //THIEF
byte.Parse(values[4], NumberFormatInfo.InvariantInfo), //ENCHANTER
byte.Parse(values[5], NumberFormatInfo.InvariantInfo), //CLOWN
byte.Parse(values[6], NumberFormatInfo.InvariantInfo), //KNIGHT
byte.Parse(values[7], NumberFormatInfo.InvariantInfo), //ASSASIN
byte.Parse(values[8], NumberFormatInfo.InvariantInfo), //SPECIALIST
byte.Parse(values[9], NumberFormatInfo.InvariantInfo), //SAGE
byte.Parse(values[10], NumberFormatInfo.InvariantInfo), //GAMBLER
byte.Parse(values[11], NumberFormatInfo.InvariantInfo), //FALCATA
byte.Parse(values[12], NumberFormatInfo.InvariantInfo), //FPRSYTHIE
byte.Parse(values[13], NumberFormatInfo.InvariantInfo), //NEMOPHILA
byte.Parse(values[14], NumberFormatInfo.InvariantInfo) //VEILCHENBLAU
};
break;
case "ROW": goto Add;
}
break;
}
continue;
Add:
this.item_drops.Add(item.item, item);
}
}
}
private void BackgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
ReportProgress?.Invoke(this, e);
}
/// <summary>
/// After configuring the .cscfg file, this function publishes the package to Azure
/// </summary>
public bool PublishServiceToAzure(ReportProgress reportDelegate, ReDoInitializeDB reDoInitializeDB)
{
this.reportDelegate = reportDelegate;
report(10, "Creating a broker object ...");
AzureManagementBroker broker;
try
{
// Create hostedservice if it does not exist in Azure
broker = new AzureManagementBroker(_settings.DeploymentName,
_settings.ManagementCert.Thumbprint,
new Guid(_settings.SubscriptionId),
_settings.ServiceName,
_settings.StorageName,
_settings.StorageKey,
null,
null);
try
{
broker.CreateHostedServiceIfNotExist(_settings.ServiceName, _settings.Location);
}
catch (Exception ex)
{
report(10, "Error: " + ex.Message + ". Please check and try later.");
return false;
}
report(20, "Adding the certificate to service ...");
IAsyncAzureOperation opServiceCert = broker.AddCertificateToService(_settings.ServiceCert, Password, CertificateLocation.AzureManagement);
opServiceCert.WaitForCompletion(TimeSpan.MaxValue);
if (opServiceCert.GetOperationStatus() == AzureOperationStatus.Failed)
{
report(20, "Error: " + opServiceCert.ErrorMessage());
return false;
}
/***************************************************************************************
//**** Create two default firewall filters for the newly-created SQL server
//1: 0.0.0.0 to 0.0.0.0
//2. IP address to IP address
***************************************************************************************/
report(30, "Creating firewall rules ...");
broker.CreateFirewallRule(_settings.SqlServerName);
string localIP = broker.CreateFirewallRuleWithIPDetect(_settings.SqlServerName, "FirewallWithIP");
string[] IPRange = GenerateIPRange(localIP);
broker.CreateFirewallRule(_settings.SqlServerName, "RangeFireWall", IPRange[0], IPRange[1]);
// If a user sets InitializeDBOnline = false, then do the initializeDB from local machine
// or else, create database and InitializeDB at Azure
if (!_settings.InitializeDBOnline)
{
report(40, "Creating database ...");
// Create a new database under the newly-created SQL Server
try
{
List<string> listOfDB = GetExistingDatabases(_settings.SqlServerName, _settings.SqlServerUser, _settings.SqlServerPassword);
// If no database named as settings.DBName is found, create one
if (listOfDB.IndexOf(_settings.DBName) == -1)
{
CreateDatabase(_settings.SqlServerName, _settings.DBName, _settings.SqlServerUser, _settings.SqlServerPassword, Maxsize);
}
}
catch (SqlException e)
{
report(40, "Error from SQL server " + e.Server + ": " + e.Message);
return false;
}
catch (Exception e)
{
report(40, "Error: " + e.Message);
return false;
}
report(50, "Initializing database ...");
if (DoInitializeDB(report, reDoInitializeDB, true) == false)
{
report(50, "Error: Initializing database failed. Please check AzureSampleService.log for details.");
return false;
}
}
// Start to deploy the service
AzureDeployment deployment = new AzureDeployment();
FileInfo localFile;
// Verify whether CspkgFile exists
if (File.Exists(CspkgFile))
{
// Upload package file to Azure first
localFile = new FileInfo(CspkgFile);
}
else
{
report(50, "Error: Please copy the .cspkg file to the current working folder.");
return false;
}
try
{
report(70, "Copying HPC package to blob storage ...");
broker.CopyHpcPackageToBlobStorage(localFile, DestinationName);
report(90, "Creating Azure deployment ...");
// Start to deploy the service now.
IAsyncAzureOperation op = broker.CreateAzureDeployment(File.ReadAllText(_settings.ServiceCscfg), DestinationName, out deployment);
op.WaitForCompletion(TimeSpan.MaxValue);
if (op.GetOperationStatus() != AzureOperationStatus.Succeeded)
{
report(90, "Error: " + op.ErrorMessage());
return false;
}
// Delete the service cscfg file
File.Delete((_settings.ServiceCscfg));
}
catch (Exception ex)
{
report(90, "Error: " + ex.Message);
return false;
}
}
catch (Exception exception)
{
report(90, "Error: " + exception.Message);
return false;
}
report(100, "Client Portion Complete (Azure deploying now).");
return true;
}
public PluginActionImageResult StartEditingTask(FileHandlingPluginTask argPluginTask, ReportProgress argProgress)
{
var paths = new List <string>();
if (argPluginTask.PluginAction.Identifier == _openConfiguratorAction.Identifier)
{
// Clear down after last run.
var dir = new DirectoryInfo(TempImagesPath);
foreach (FileInfo file in dir.GetFiles())
{
file.Delete();
}
// Populate with new temp images.
foreach (var path in argPluginTask.Files)
{
var filename = Path.GetFileName(path);
var tempPath = Path.Combine(TempImagesPath, filename);
File.Copy(path, tempPath);
paths.Add(tempPath);
}
StartPostCaptureStudio(paths);
return(new PluginActionImageResult());
}
if (argPluginTask.PluginAction.Identifier == _runProcessAction.Identifier)
{
StartPostCaptureProcessor(argPluginTask);
return(new PluginActionImageResult(argPluginTask.Files.ToArray()));
}
return(new PluginActionImageResult());
}
/// <summary>
/// This is a wrapper function
/// if there is an existing database in use, let the user choose whether
/// to forcibly initialize it
/// </summary>
private bool DoInitializeDB(ReportProgress report, ReDoInitializeDB reDoInitializeDB, bool firstTry)
{
// Initialize database for service deployment
int status = 0;
// Force at the 2nd time
bool forceOverride = !firstTry;
status = InitializeDB(forceOverride);
if (status == 0)
{
// Succeed
return true;
}
// Need user's decision on whether to forcibly initialize database
else if (status == -2)
{
// Pop up a messageBox for user to decide whether to forcibly initialize the database
bool willRedoInitializeDB = ((bool)_form.Invoke(reDoInitializeDB) && firstTry);
if (willRedoInitializeDB == true)
{
return DoInitializeDB(report,reDoInitializeDB, false);
}
else
{
return false;
}
}
else
{
return false;
}
}
public void SetReportProgressDelegate(ReportProgress reportProress)
{
this.m_ReportProgress = reportProress;
}
internal PlayGamesAchievement(ReportProgress progressCallback)
{
mProgressCallback = progressCallback;
}
public void Scan(string baseDir, string[] extensions, ReportProgress progressReport)
{
const int MAX_THREADS = 50;
var dirs = new Stack<string>();
dirs.Push(baseDir);
Semaphore sync = new Semaphore(MAX_THREADS, MAX_THREADS);
while(dirs.Count > 0)
{
var dir = dirs.Pop();
if (progressReport != null)
{
progressReport(-1, string.Format(Properties.Resources.FormatAddDir, dir));
}
try
{
foreach(var i in Directory.EnumerateDirectories(dir))
{
dirs.Push(i);
}
}
catch
{ }
try
{
var files = EnumFiles(dir, extensions);
foreach(var f in files)
{
System.Diagnostics.Debug.WriteLine(f);
while (!sync.WaitOne())
{
}
while (!ThreadPool.QueueUserWorkItem((object a) =>
{
try
{
string fileName = a as string;
if (fileName != null)
{
ProcessSingleFile(fileName);
}
}
finally
{
sync.Release();
}
}, f)) ;
}
}
catch
{ }
}
for(int i = 0; i < MAX_THREADS; )
{
if (sync.WaitOne(-1))
{
i++;
}
}
}
public void Add(IEnumerable<DocItem> items, string commonTags, ReportProgress progressReport)
{
string[] sc = { ";", " ", "," };
string[] tags = commonTags.Split(sc, StringSplitOptions.RemoveEmptyEntries);
using(var db = new AppDataBase())
{
var registeredTags = from i in db.Tags
where tags.Contains(i.Name.ToLower())
select i;
List<Tag> allTags = new List<Tag>(registeredTags);
if (progressReport != null)
{
progressReport(-1, Properties.Resources.AddTags);
}
using (var transaction = db.Database.BeginTransaction())
{
var newTags = tags.Except(registeredTags.Select(x => x.Name), StringComparer.InvariantCultureIgnoreCase);
// add new tags and link with document
foreach (var i in newTags)
{
var newTagRecord = db.Tags.Add(new Tag()
{
Name = i
});
allTags.Add(newTagRecord);
}
db.SaveChanges();
transaction.Commit();
}
using (var transaction = db.Database.BeginTransaction())
{
int totalItems = items.Count();
int c = 0;
foreach (var i in items)
{
c++;
i.Tags = allTags;
db.Items.Add(i);
if (progressReport != null)
{
int percentage = c * 100;
percentage /= totalItems;
progressReport(percentage, string.Format(Properties.Resources.FormatAddFile, i.FileName));
}
}
progressReport(-1, Properties.Resources.MsgCommitingChanges);
db.SaveChanges();
transaction.Commit();
}
}
}
public void SetReportProgressDelegate(ReportProgress reportProress)
{
this.m_ReportProgress = reportProress;
this.m_ProgressHandle.SetReportProgressDelegate(reportProress);
}
