private void IncrementProgress(IProgressCallback progressCallback)
{
if (progressCallback != null)
{
progressCallback.Increment(1);
}
}
private static bool DoDownloadFileDirectly(string uri, string targetFile, IProgressCallback callback = null)
{
if (!File.Exists(targetFile))
{
var tempFile = new FileInfo(targetFile).DirectoryName + "/" + Path.GetFileName(Path.GetTempFileName());
var webClient = new WebClient()
{
Proxy = null
};
Console.WriteLine(" " + Path.GetFileName(uri) + " ...");
webClient.DownloadFile(new Uri(uri), tempFile);
if (File.Exists(tempFile))
{
Console.WriteLine(" " + Path.GetFileName(uri) + " ... done.");
File.Move(tempFile, targetFile);
}
else
{
Console.WriteLine(" " + Path.GetFileName(uri) + " ... failed.");
}
}
return File.Exists(targetFile);
}
private static bool DoDownloadFileDirectly(string uri, string targetFile, IProgressCallback callback = null)
{
if (!File.Exists(targetFile))
{
var tempFile = new FileInfo(targetFile).DirectoryName + "/" + Path.GetFileName(Path.GetTempFileName());
var webClient = new WebClient()
{
Proxy = null
};
Console.WriteLine(" " + Path.GetFileName(uri) + " ...");
webClient.DownloadFile(new Uri(uri), tempFile);
if (File.Exists(tempFile))
{
Console.WriteLine(" " + Path.GetFileName(uri) + " ... done.");
File.Move(tempFile, targetFile);
}
else
{
Console.WriteLine(" " + Path.GetFileName(uri) + " ... failed.");
}
}
return(File.Exists(targetFile));
}
/// <summary>
/// Fill reference allele from genome fasta file.
/// </summary>
/// <param name="snpItems"></param>
/// <param name="fastaFile"></param>
/// <param name="progress"></param>
public static void FillReferenceAlleleFromFasta(this IEnumerable<SNPItem> snpItems, string fastaFile, IProgressCallback progress = null)
{
if (progress == null)
{
progress = new ConsoleProgressCallback();
}
var dic = snpItems.ToGroupDictionary(m => m.Chrom);
progress.SetMessage("Filling reference allele from {0} file ...", fastaFile);
using (var sw = new StreamReader(fastaFile))
{
var ff = new FastaFormat();
Sequence seq;
while ((seq = ff.ReadSequence(sw)) != null)
{
progress.SetMessage("chromosome " + seq.Name + " ...");
var chr = HumanChromosomeToInt(seq.Name);
if (dic.ContainsKey(chr))
{
var snps = dic[chr];
foreach (var snp in snps)
{
snp.RefChar = char.ToUpper(seq.SeqString[snp.Position - 1]);
}
}
}
}
progress.SetMessage("Filling reference allele finished.");
}
private void ExportConversationsAsync()
{
ExportedFilenameGenerator filenameGenerator = new ExportedFilenameGenerator();
string folderName = filenameGenerator.CreateExportFolderNameSuggestion();
string outputPath = System.IO.Path.Combine(folderPathTextBox.Text, folderName);
BackgroundWorker backgroundWorker = new BackgroundWorker();
_progressCallback = new ProgressCallback(backgroundWorker);
backgroundWorker.WorkerReportsProgress = true;
backgroundWorker.WorkerSupportsCancellation = true;
backgroundWorker.DoWork += OnDoWork;
backgroundWorker.ProgressChanged += OnProgressChanged;
backgroundWorker.RunWorkerCompleted += OnWorkerCompleted;
ExportMultipleDialogModel.ExportFormat exportFormat = GetExportFormat();
AsyncExportingProgressParams exportingParams = new AsyncExportingProgressParams(_progressCallback, _model, exportFormat, outputPath);
SetUiToExportInProgress();
backgroundWorker.RunWorkerAsync(exportingParams);
}
/// <summary>
/// 更新本地数据库
/// </summary>
/// <param name="parameters"></param>
private static void UpdateProcess(object parameters)
{
object[] parameterArr = parameters as object[];// { tableName, sqlStr, index, updateRecordTable.Rows.Count };
string tableName = parameterArr[0].ToString();
string sqlStr = parameterArr[1].ToString();
IProgressCallback callBack = (IProgressCallback)parameterArr[2];
DataTable ServerTable = parameterArr[3] as DataTable;
DataTable ServerDataCache = parameterArr[4] as DataTable;
//从远程获取要更新的记录
DataTable NewDataTable = GetServerDataTalbe(sqlStr);
NewDataTable.TableName = tableName;
//更新dataCache
parameterArr = new object[] { tableName, NewDataTable, ServerTable, ServerDataCache };
UpdateDataCache(parameterArr);
lock (ProcessInfoList)
{
if (ProcessInfoList.ContainsKey(tableName.ToLower().Trim()))
{
ProcessInfo pi = ProcessInfoList[tableName];
if (NewDataTable.Rows.Count <= pi.TableRowsCount)
{
pi.CompletedRowsCount += NewDataTable.Rows.Count;
ProcessInfoList[tableName] = pi;
}
callBack.SetText("正在更新表：" + tableName + "……已完成" + ((int)((double)pi.CompletedRowsCount / pi.TableRowsCount * 100)).ToString() + "%");
}
}
//更新进度条
Agent_updateProcessEvent(callBack, tableName);
}
private void DoSomeWork(object status)
{
errorList = new StringBuilder();
errorMail = false;
errorList.AppendLine("Email not sent to:");
callback = status as IProgressCallback;
try
{
callback.Begin(0, nbrTxtInc);
SendContributieIncassoAankondiging();
SendInschrijfIncassoAankondiging();
callback.WaitOK();
}
catch (System.Threading.ThreadAbortException)
{
// We want to exit gracefully here (if we're lucky)
}
catch (System.Threading.ThreadInterruptedException)
{
// And here, if we can
}
catch (Exception ex)
{
GuiRoutines.ExceptionMessageBox(this, ex);
}
finally
{
if (callback != null)
{
callback.End();
}
}
}
public ConditionProcessor(PolicyEngineCache policyEngineCache, IProgressCallback callback)
{
if (null == policyEngineCache)
throw new Exceptions.ArgumentNullException("policyEngineCache", "Invalid policy engine cache");
m_policyEngineCache = policyEngineCache;
m_progressCallback = callback;
}
public void Load(IProgressCallback progress)
{
for (int i = 0; i < 50; i++)
{
System.Threading.Thread.Sleep(10);
progress.ProgressUpdated(i / 50.0f);
}
}
protected override EnforceResponse CallEnforcer(IProgressCallback callback)
{
EnforceResponse er = new EnforceResponse();
er.Properties = new CustomProperty[] {
new CustomProperty("Error.Test", "This is a fake error to test the enforce error handling."),
new CustomProperty("Error.Test", "Exception in fake enforce handler"),
new CustomProperty("Error.Test", "Block") };
return er;
}
protected override IContentEnforcer GetContentEnforcer(IProgressCallback eventSink)
{
if (null == m_factory)
{
m_factory = new PolicyEngineFactory();
}
return m_factory.CreateContentEnforcer(eventSink);
}
public void Submit(VoiceProfileViewModel viewModel, IProgressCallback progressCallback)
{
this.progressCallback = progressCallback;
this.progressCallback.SetText("Initialize");
this.InitializeKeepAliveService(viewModel);
this.InitializeTerminalClient(viewModel);
this.pingService.Send();
this.telnet.Send(viewModel);
}
public AsyncExportingProgressParams(IProgressCallback progressCallback, ExportMultipleDialogModel model, ExportMultipleDialogModel.ExportFormat exportFormat, string exportPath)
{
ProgressCallback = progressCallback;
Model = model;
ExportFormat = exportFormat;
ExportPath = exportPath;
}
public AsyncExportingProgressParams(IProgressCallback progressCallback, ExportMultipleDialogModel model, ExportMultipleDialogModel.ExportFormat exportFormat, string exportPath)
{
ProgressCallback = progressCallback;
Model = model;
ExportFormat = exportFormat;
ExportPath = exportPath;
}
public PolicyEngineCache(IPolicyCache policyCache, IProgressCallback callback)
{
if (null == policyCache)
throw new Workshare.Policy.Exceptions.ArgumentNullException("policyCache", "Invalid policy cache");
m_policyCache = policyCache;
m_progressCallback = callback;
m_policyEngines = new Dictionary<string, Dictionary<string, PolicyEngine>>();
}
public IIdentifiedProteinGroupFilter GetNotContaminationDescriptionFilter(IProgressCallback progress)
{
var result = GetContaminationDescriptionFilter(progress);
if (result != null)
{
return new IdentifiedProteinGroupNotFilter(result);
}
return null;
}
private void BuildAnalyses(object status)
{
try
{
IProgressCallback callback = status as IProgressCallback;
callback.SetRange(0, CheckedIndices.Count - 1);
callback.Begin();
int expectedCount = uCtrlNumberPerCase.Value.Activated ? uCtrlNumberPerCase.Value.Value : -1;
PackableBrick packable = cbBoxes.SelectedType as PackableBrick;
// build list of analyses
for (int i = 0; i < CheckedIndices.Count; ++i)
{
try
{
if (callback.IsAborting)
{
break;
}
callback.StepTo(i);
callback.SetText(string.Format(Resources.ID_EVALUATINGCASE, i + 1, CheckedIndices.Count));
if ((chklbCases.Items[CheckedIndices[i]] as ItemBaseCB).Item is BoxProperties caseProperties)
{
// build constraint set
ConstraintSetBoxCase constraintSet = new ConstraintSetBoxCase(caseProperties);
constraintSet.SetAllowedOrientations(uCtrlCaseOrient.AllowedOrientations);
if (uCtrlNumberPerCase.Value.Activated)
{
constraintSet.SetMaxNumber(uCtrlNumberPerCase.Value.Value);
}
// build solver + get analyses
SolverBoxCase solver = new SolverBoxCase(packable, caseProperties);
var listAnalyses = solver.BuildAnalyses(constraintSet, false);
foreach (var analysis in listAnalyses)
{
if ((-1 == expectedCount) || (expectedCount == analysis.Solution.ItemCount))
{
Analyses.Add(analysis);
}
}
}
}
catch (Exception) {}
}
callback.SetText(Resources.ID_SORTINGSOLUTIONS);
// sort analysis
Analyses.Sort(new AnalysisComparer());
callback.End();
}
catch (Exception) {}
}
public CompositeProcessor <PeakList <Peak> > GetProcessor(string fileName, IProgressCallback callBack)
{
CompositeProcessor <PeakList <Peak> > result = new CompositeProcessor <PeakList <Peak> >();
if (!this.OutputMzXmlFormat)
{
AddGeneralProcessor(result);
}
if (RemoveIons)
{
if (RemoveIsobaricIons)
{
result.Add(GetIsobaricProcessor());
}
if (RemoveSpecialIons)
{
var ranges = ParseRemoveMassRange();
foreach (var range in ranges)
{
result.Add(new PeakListRemoveMassRangeProcessor <Peak>(range.From, range.To));
}
}
}
if (Deisotopic)
{
result.Add(new PeakListDeisotopicByChargeProcessor <Peak>(ProductIonPPM));
}
if (PrecursorOptions.RemovePrecursor)
{
result.Add(new PeakListRemovePrecursorProcessor <Peak>(this.PrecursorOptions));
}
if (ChargeDeconvolution)
{
result.Add(new PeakListDeconvolutionByChargeProcessor <Peak>(ProductIonPPM));
if (Deisotopic)
{
result.Add(new PeakListDeisotopicByChargeProcessor <Peak>(ProductIonPPM));
}
}
if (KeepTopX)
{
result.Add(new PeakListTopXProcessor <Peak>(TopX));
}
return(result);
}
private void CheckForCancel(IProgressCallback progressCallback)
{
if (progressCallback == null)
{
return;
}
if (progressCallback.IsCancelRequested)
{
progressCallback.AcceptCancel();
throw new OperationCanceledException();
}
}
/// <summary>
/// Thread start. Use in a ThreadStart. No internal checking is done to
/// make sure that the model doesn't change during processing so this
/// must be ensured by the calling code.
/// </summary>
/// <param name="status">The IProgressCallback implementation that allows
/// for progress to be tracked in a gui.</param>
public void Start(object status)
{
mCallback = status as IProgressCallback;
try
{
FFMPEGToVideo();
}
finally
{
mCallback.End();
}
}
public static void SlimDocument(XmlDocument xml, IProgressCallback progress)
{
var xmlHelper = new XmlHelper(xml);
List <XmlNode> proteins = xmlHelper.GetChildren(xml.DocumentElement, "protein");
progress.SetRange(0, proteins.Count);
int index = 0;
var reg = new Regex(@"(\S{8,})");
foreach (XmlNode protein in proteins)
{
progress.SetPosition(index++);
List <XmlNode> peptides = xmlHelper.GetChildren(protein, "peptide");
foreach (XmlNode peptide in peptides)
{
XmlNode chro = xmlHelper.GetValidChild(peptide, "chro");
string oldValue = chro.InnerText;
string[] parts = oldValue.Split(new[] { ';' });
for (int i = 0; i < parts.Length; i++)
{
parts[i] = reg.Replace(parts[i], new MatchEvaluator(FormatString));
}
string newValue = StringUtils.Merge(parts, ";");
if (oldValue.Equals(newValue)) //不需要进行slim
{
return;
}
double lightMass, heavyMass;
if (peptide.Attributes["lightMass"] != null)
{
lightMass = MyConvert.ToDouble(peptide.Attributes["lightMass"].Value);
heavyMass = MyConvert.ToDouble(peptide.Attributes["heavyMass"].Value);
peptide.Attributes["lightMass"].Value = MyConvert.Format("{0:0.0000}", lightMass);
peptide.Attributes["heavyMass"].Value = MyConvert.Format("{0:0.0000}", heavyMass);
}
else if (peptide.Attributes["lightStartMass"] != null)
{
lightMass = MyConvert.ToDouble(peptide.Attributes["lightStartMass"].Value);
heavyMass = MyConvert.ToDouble(peptide.Attributes["heavyStartMass"].Value);
peptide.Attributes["lightStartMass"].Value = MyConvert.Format("{0:0.0000}", lightMass);
peptide.Attributes["heavyStartMass"].Value = MyConvert.Format("{0:0.0000}", heavyMass);
}
}
}
}
public void Output(DEResFolder curResFolder)
{
if (curResFolder != null)
{
this.curFolder = curResFolder;
this.InitResInfo();
this.TotalNum = this.GetResDataCount();
if (this.TotalNum == 0)
{
MessageBoxPLM.Show("资源的记录数为零，不能导出", "资源数据导出", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
}
else
{
this.TotalPage = ((this.TotalNum % this.showNum) == 0) ? (this.TotalNum / this.showNum) : ((this.TotalNum / this.showNum) + 1);
this.attrShow = new PLReference().GetDefAttrLst(this.curFolder.Oid, emTreeType.NodeTree);
foreach (DEDefAttr attr in this.attrShow)
{
if (!attr.ISVISUAL)
{
for (int i = this.attrList.Count - 1; i >= 0; i--)
{
DEMetaAttribute attribute = this.attrList[i] as DEMetaAttribute;
if (attribute.Oid == attr.ATTROID)
{
this.attrList.RemoveAt(i);
}
}
}
}
FrmOutputOption option = new FrmOutputOption(this.TotalPage, this.attrList);
if (option.ShowDialog() == DialogResult.OK)
{
SaveFileDialog dialog;
this.StartNum = option.StartPage;
this.EndNum = option.EndPage;
this.IsMultiPageOut = option.IsMultiPage;
if (this.saveFile(out dialog))
{
IProgressCallback progressWindow = ClientData.GetProgressWindow();
ArrayList state = new ArrayList {
progressWindow,
dialog.FileName
};
ThreadPool.QueueUserWorkItem(new WaitCallback(this.outPageExcel), state);
progressWindow.ShowWindow();
}
}
}
}
}
/// <summary>
/// 精确控制进度条
/// </summary>
/// <param name="callBack"></param>
/// <param name="step"></param>
/// <returns></returns>
private static float ProgressGo(IProgressCallback callBack, float step)
{
float newStep = 0;
if (step < 99)
{
newStep = step + 1;
}
else
{
newStep = step;
}
callBack.StepTo((Int32)newStep);
return(newStep);
}
private static Int32 ProgressGo(IProgressCallback callBack, Int32 step)
{
Int32 newStep = 0;
if (step <= 99)
{
newStep = step + 1;
}
else
{
newStep = step;
}
callBack.StepTo(newStep);
return(newStep);
}
protected override EnforceResponse CallEnforcer(IProgressCallback callback)
{
EnforceResponse er = new EnforceResponse();
if (!m_aborted)
{
er.Properties = new CustomProperty[] { new CustomProperty("ABORT", "true") };
m_aborted = true;
AbortHit = true;
}
else
{
er.Properties = new CustomProperty[] { new CustomProperty("SUCCESS", "true") };
}
return er;
}
public MultipleRaw2OneMgfThreadProcessor(DirectoryInfo rawDir, FileInfo saveToFile,
IRawFile2 rawFile, IPeakListWriter <Peak> writer,
double retentionTimeTolerance, double ppmPrecursorTolerance,
double ppmPeakTolerance, IProcessor <PeakList <Peak> > pklProcessor,
IProgressCallback eachProcessorProgress)
{
this.rawDir = rawDir;
this.saveToFile = saveToFile;
this.rawFile = rawFile;
this.writer = writer;
this.retentionTimeTolerance = retentionTimeTolerance;
this.ppmPrecursorTolerance = ppmPrecursorTolerance;
this.ppmPeakTolerance = ppmPeakTolerance;
this.pklProcessor = pklProcessor;
this.eachProcessorProgress = eachProcessorProgress;
}
public ExportMultipleDialogView(IConversationManager conversationManager, IDisplayOptionsReadOnly displayOptions)
{
InitializeComponent();
IFileSystem exportFileSystem = new OsFileSystem();
ExportErrorFormatter exportErrorFormatter = new ExportErrorFormatter();
_model = new ExportMultipleDialogModel(conversationManager, displayOptions, exportFileSystem, exportErrorFormatter);
_progressCallback = null;
Loaded += delegate
{
folderPathTextBox.Text = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
};
}
/// <summary>
/// The send data.
/// </summary>
/// <param name="data">
/// The data.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public string SendData(IList<TravelRoute> data, IProgressCallback callback)
{
if (data == null || data.Count < 1)
{
return null;
}
var newPkg = new DataPackage<TravelRoute>(data);
var pkgSyncer = this.DataSynchronizer as IPackageSyncer<TravelRoute>;
if (pkgSyncer != null)
{
pkgSyncer.Send(newPkg, callback);
}
return newPkg.Id;
}
public ExportMultipleDialogView(IConversationManager conversationManager, IDisplayOptionsReadOnly displayOptions)
{
InitializeComponent();
IFileSystem exportFileSystem = new OsFileSystem();
ExportErrorFormatter exportErrorFormatter = new ExportErrorFormatter();
_model = new ExportMultipleDialogModel(conversationManager, displayOptions, exportFileSystem, exportErrorFormatter);
_progressCallback = null;
Loaded += delegate
{
folderPathTextBox.Text = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
};
}
public void ExportConversations(ExportFormat exportFormat, string exportPath, IProgressCallback progressCallback)
{
IConversationExporter conversationExporter;
switch (exportFormat)
{
case ExportFormat.Html:
conversationExporter = new ConversationExporterHtml(_exportFileSystem);
break;
case ExportFormat.Plaintext:
conversationExporter = new ConversationExporterPlaintext(_exportFileSystem);
break;
default:
throw new ArgumentException("Unrecognized export format.");
}
_exportErrors = conversationExporter.ExportMultipleConversations(_conversationManager, _displayOptions, exportPath, progressCallback);
}
public IIdentifiedProteinGroupFilter GetContaminationDescriptionFilter(IProgressCallback progress)
{
if (HasContaminationDescriptionFilter())
{
if (_contaminationGroupFilter == null)
{
var acParser = GetAccessNumberParser();
var map = IdentifiedResultUtils.GetContaminationAccessNumbers(acParser, Location, ContaminationDescriptionPattern, progress);
_contaminationGroupFilter = new IdentifiedProteinGroupContaminationMapFilter(acParser, map);
}
return _contaminationGroupFilter;
}
return null;
}
/// <summary>
/// The receive packages.
/// </summary>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="int"/>.
/// </returns>
public int ReceivePackages(IProgressCallback callback)
{
var pkgSyncer = this.DataSynchronizer as IPackageSyncer<TravelRoute>;
int newPackageCount = 0;
if (pkgSyncer != null)
{
var importedPkg = this.GetImportedPackages(callback);
var newData = pkgSyncer.Receive(importedPkg, callback);
if (newData != null && newData.Count > 0)
{
this.AddData(newData, callback);
newPackageCount = newData.Count;
}
}
return newPackageCount;
}
public static HashSet <string> GetContaminationAccessNumbers(IStringParser <string> acParser, string fastaFilename, string contaminationDescriptionPattern,
IProgressCallback progress)
{
HashSet <string> result = new HashSet <string>();
if (progress == null)
{
progress = new EmptyProgressCallback();
}
Regex reg = new Regex(contaminationDescriptionPattern, RegexOptions.IgnoreCase);
progress.SetMessage("Get contamination map from database ...");
var ff = new FastaFormat();
using (var sr = new StreamReader(fastaFilename))
{
progress.SetRange(1, sr.BaseStream.Length);
Sequence seq;
while ((seq = ff.ReadSequence(sr)) != null)
{
if (progress.IsCancellationPending())
{
throw new UserTerminatedException();
}
progress.SetPosition(sr.GetCharpos());
string ac = acParser.GetValue(seq.Name);
if (reg.Match(seq.Reference).Success)
{
result.Add(ac);
}
}
}
progress.SetMessage("Get contamination map from database finished.");
return(result);
}
private void OnWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
_progressCallback = null;
if (e.Cancelled)
{
SetUiToExportFailed("Export canceled.");
}
else if (e.Error != null)
{
SetUiToExportFailed(e.Error.Message);
}
else if (!_model.ExportSucceeded)
{
SetUiToExportFailed(_model.ErrorMessage);
}
else
{
SetUiToExportSucceeded();
}
}
private void outPageExcel(object objs)
{
ArrayList list = (ArrayList)objs;
IProgressCallback callback = list[0] as IProgressCallback;
string strFileName = list[1] as string;
try
{
callback.Begin(0, 100);
callback.SetText("正在生成{'资源'}的导出文件……");
this.DoOutFile(strFileName);
}
catch (Exception exception)
{
PrintException.Print(exception);
}
finally
{
callback.End();
}
}
/// <summary>
/// 更新完成后，表总表记录进行更新
///
/// </summary>
/// <param name="callBack"></param>
/// <param name="TalbeID"></param>
/// <param name="tableName"></param>
/// <param name="CompleteRowsCount"></param>
private static void Agent_updateProcessEvent(IProgressCallback callBack, string tableName)
{
try
{
int totalRowsCount = 0;
int totalCompleteRowsCount = 0;
lock (ProcessInfoList)
{
foreach (string key in ProcessInfoList.Keys)
{
totalCompleteRowsCount += ProcessInfoList[key].CompletedRowsCount;
totalRowsCount += ProcessInfoList[key].TableRowsCount;
}
}
double completeRate = (double)totalCompleteRowsCount / totalRowsCount;
ProgressGo(callBack, (Int32)(completeRate * 100));
}
catch (Exception e)
{
logger.Error(e.Message);
}
}
public List<ExportError> ExportMultipleConversations(IEnumerable<IConversation> conversations, IDisplayOptionsReadOnly displayOptions, string exportPath, IProgressCallback progressCallback)
{
List<ExportError> exportErrors = new List<ExportError>();
string createdFolderPath = FileCreator.CreateNewDirectoryWithRenameAttempts(exportPath, _exportFileSystem, MaxRenameAttempts);
ExportedFilenameGenerator filenameGenerator = new ExportedFilenameGenerator();
foreach (IConversation conversation in conversations)
{
CheckForCancel(progressCallback);
//
// Don't export empty conversations
//
if (conversation.MessageCount == 0)
{
IncrementProgress(progressCallback);
continue;
}
try
{
string filename = filenameGenerator.CreateExportFilenameSuggestion(conversation) + "." + GetExportFileExtension();
string exportFilename = Path.Combine(createdFolderPath, filename);
List<ExportError> currentErrors = Export(conversation, displayOptions, exportFilename);
exportErrors.AddRange(currentErrors);
}
catch (Exception ex)
{
exportErrors.Add(new ExportError(conversation, ex));
}
IncrementProgress(progressCallback);
}
return exportErrors;
}
private static void OnDoWork(object sender, DoWorkEventArgs e)
{
AsyncExportingProgressParams exportingParams = (AsyncExportingProgressParams)e.Argument;
ExportMultipleDialogModel model = exportingParams.Model;
ExportMultipleDialogModel.ExportFormat exportFormat = exportingParams.ExportFormat;
string exportPath = exportingParams.ExportPath;
IProgressCallback progressCallback = exportingParams.ProgressCallback;
try
{
progressCallback.Begin(model.ConversationCount);
model.ExportConversations(exportFormat, exportPath, progressCallback);
progressCallback.End();
}
catch (OperationCanceledException)
{
e.Cancel = true;
}
}
protected override EnforceResponse CallEnforcer(IProgressCallback callback)
{
// Uncomment to generate new resources...
//Workshare.PolicyContent.EnforceResponse enforceResponse = base.CallEnforcer(callback);
string resourceName = string.Format("Workshare.Policy.ClientManager.Tests.Resources.{0}.enforceresponse", m_methodBase.Name);
Stream stream = GetType().Assembly.GetManifestResourceStream(resourceName);
XmlSerializer serializer = new XmlSerializer(typeof(EnforceResponse));
EnforceResponse enforceResponse = (EnforceResponse) serializer.Deserialize(stream);
foreach (var attachment in enforceResponse.ModifiedRequest.Attachments)
{
string tempFile = m_lcofm.GetLocalCopyOfFileTarget(attachment.Name);
File.WriteAllBytes(tempFile, attachment.Content);
attachment.FileName = tempFile;
attachment.File = new FCS.Lite.Interface.File(tempFile, attachment.Name);
}
//Stream stream = File.Open(string.Format("{0}.enforceresponse", m_methodBase.Name), FileMode.Create);
//serializer.Serialize(stream, enforceResponse);
return enforceResponse;
}
public void Downloader(object status)
{
try
{
IProgressCallback callback = status as IProgressCallback;
callback.Begin(0, requiredDependancies.Count);
WebClient web = new WebClient();
for (int i = 0; i < requiredDependancies.Count; i++)
{
if (!File.Exists("Mods/" + requiredDependancies[i]))
{
MelonLogger.Log("Downloading " + requiredDependancies[i]);
web.DownloadFileTaskAsync("https://raw.githubusercontent.com/KosmicShovel/BTD6-Mods/master/BTD6.py/DLL/" + requiredDependancies[i], "Mods/" + requiredDependancies[i]).GetAwaiter().GetResult();
MelonLogger.Log("Downloaded " + requiredDependancies[i] + "!");
Console.WriteLine("");
}
callback.StepTo(i);
}
callback.End();
MelonLogger.Log("THE WIZARD WILL NOW RESTART SO YOU CAN USE THE SCRIPT MODS!");
}
catch (System.FormatException) {}
}
private void ProcessDatasetFromSameEngine(IProgressCallback progress, Action <List <IIdentifiedSpectrum>, IScoreFunction> process, bool hasDuplicatedSpectrum)
{
Func <Dataset, Dataset, bool> preFunc = (m1, m2) => m1.Options.SearchEngine == m2.Options.SearchEngine;
var overlaps = FindOverlap(preFunc);
if (overlaps.Count > 0)
{
progress.SetMessage("Filtering spectra from same engine but different search parameters ...");
foreach (var dsList in overlaps)
{
var spectra = dsList.GetSpectra();
Console.Write(spectra.Count);
process(spectra, dsList.First().Options.ScoreFunction);
Console.WriteLine(" -> {0}", spectra.Count);
ResetClassificationTag(dsList, spectra);
dsList[0].Spectra = spectra;
dsList[0].HasDuplicatedSpectrum = hasDuplicatedSpectrum;
//删除其余dataset。
for (int i = 1; i < dsList.Count; i++)
{
this.Remove(dsList[i]);
}
//new MascotPeptideTextFormat().WriteToFile(@"U:\sqh\hppp\orbitrap\summary\overlap\new.merged.peptides", spectra);
}
progress.SetMessage("Filtering spectra from same engine but different search parameters finished.");
}
}
private static bool DoDownloadFileAsync(string uri, string targetFile, IProgressCallback callback = null)
{
if (!File.Exists(targetFile))
{
var tempFile = new FileInfo(targetFile).DirectoryName + "/" + Path.GetFileName(Path.GetTempFileName());
var webClient = new WebClient()
{
Proxy = null,
};
Console.WriteLine(" " + Path.GetFileName(uri) + " ...");
webClient.DownloadFileAsync(new Uri(uri), tempFile);
while(webClient.IsBusy)
{
if (callback != null && callback.IsCancellationPending())
{
webClient.CancelAsync();
return false;
}
Thread.Sleep(100);
}
if (File.Exists(tempFile))
{
Console.WriteLine(" " + Path.GetFileName(uri) + " ... done.");
File.Move(tempFile, targetFile);
}
else
{
Console.WriteLine(" " + Path.GetFileName(uri) + " ... failed.");
}
}
return File.Exists(targetFile);
}
private static bool DoDownloadFileAsync(string uri, string targetFile, IProgressCallback callback = null)
{
if (!File.Exists(targetFile))
{
var tempFile = new FileInfo(targetFile).DirectoryName + "/" + Path.GetFileName(Path.GetTempFileName());
var webClient = new WebClient()
{
Proxy = null,
};
Console.WriteLine(" " + Path.GetFileName(uri) + " ...");
webClient.DownloadFileAsync(new Uri(uri), tempFile);
while (webClient.IsBusy)
{
if (callback != null && callback.IsCancellationPending())
{
webClient.CancelAsync();
return(false);
}
Thread.Sleep(100);
}
if (File.Exists(tempFile))
{
Console.WriteLine(" " + Path.GetFileName(uri) + " ... done.");
File.Move(tempFile, targetFile);
}
else
{
Console.WriteLine(" " + Path.GetFileName(uri) + " ... failed.");
}
}
return(File.Exists(targetFile));
}
public CCreatorStylesheet( CGedcom gedcom, IProgressCallback progress, string sW3cfile, string sCssFilename, string sBackgroundImageFilename )
: base(gedcom, progress, sW3cfile)
{
m_sCssFilename = sCssFilename;
m_sBackgroundImageFilename = sBackgroundImageFilename;
}
/// <summary>
/// The reset data.
/// </summary>
/// <param name="data">
/// The data.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
public void ResetData(IList<TravelRoute> data, IProgressCallback callback)
{
if (data == null || data.Count < 1)
{
return;
}
ProgressDialog.ExecuteTask(
null,
"Reset Database",
"Please wait...",
"SQLiteDbReset",
ProgressBarStyle.Marquee,
this.Logger,
cb =>
{
cb.Begin();
this.Logger.Info("Clear database");
this.Reset(cb);
this.AddData(data, cb);
});
}
/// <summary>
/// Fill dbsnp information. The name of SNPItem will be replaced by dbSNP name and the mapping between dbSNP name and old SNPItem name will be returned.
/// </summary>
/// <param name="snpItems"></param>
/// <param name="dbSnpVcfFile"></param>
/// <param name="progress"></param>
/// <returns></returns>
public static Dictionary <string, string> FillDbsnpIdByPosition(this IEnumerable <SNPItem> snpItems, string dbSnpVcfFile, IProgressCallback progress = null)
{
var sourceDbsnpMap = snpItems.ToDictionary(m => m.Name, m => m.Name);
if (progress == null)
{
progress = new EmptyProgressCallback();
}
var dic = snpItems.ToDoubleDictionary(m => m.Chrom, m => m.Position);
progress.SetMessage("Filling dbSNP id from {0} ...", dbSnpVcfFile);
using (var sr = new StreamReader(dbSnpVcfFile))
{
progress.SetRange(0, sr.BaseStream.Length);
string line;
while ((line = sr.ReadLine()) != null)
{
if (!line.StartsWith("##"))
{
break;
}
}
int linecount = 0;
Dictionary <int, SNPItem> chrMap = null;
int lastChr = -1;
while (line != null)
{
linecount++;
if (linecount % 10000 == 0)
{
progress.SetPosition(sr.GetCharpos());
}
try
{
//make sure it is SNV
if (!line.Contains("VC=SNV"))
{
continue;
}
//Even it marked as SNV, it still could be insertion/deletion
//2 179658175 rs11537855 C CC,CT . . RS=11537855;RSPOS=179658175;dbSNPBuildID=120;SSR=0;SAO=0;VP=0x050100001205000002000110;GENEINFO=TTN:7273;WGT=1;VC=SNV;SLO;NSF;REF;ASP;OTHERKG;NOC
var parts = line.Split('\t');
if (parts[3].Split(',').Any(l => l.Length != 1))
{
continue;
}
if (parts[4].Split(',').Any(l => l.Length != 1))
{
continue;
}
var chr = HumanChromosomeToInt(parts[0]);
var position = int.Parse(parts[1]);
if (lastChr != chr)
{
if (!dic.TryGetValue(chr, out chrMap))
{
continue;
}
lastChr = chr;
}
SNPItem source;
if (!chrMap.TryGetValue(position, out source))
{
continue;
}
if (!source.Name.Equals(parts[2]))
{
sourceDbsnpMap.Remove(source.Name);
sourceDbsnpMap[source.Name] = parts[2];
}
source.DbsnpRefAllele = parts[3][0];
source.DbsnpAltAllele = parts[4][0];
source.DbsnpIsReversed = parts[7].Contains(";RV;");
}
finally
{
line = sr.ReadLine();
}
}
}
var snpMap = snpItems.ToDictionary(m => m.Name);
var result = new Dictionary <string, string>();
foreach (var r in sourceDbsnpMap)
{
result[r.Value] = r.Key;
if (!r.Key.Equals(r.Value))
{
snpMap[r.Key].Name = r.Value;
}
}
progress.SetMessage("Filling dbSNP id finished.");
return(result);
}
public static void FindAllele2FrequencyFrom1000GomeByName(this IEnumerable <SNPItem> snpItems, string g1000VcfFile, IProgressCallback progress = null)
{
DoFillAllele2FrequencyFrom1000Gome(snpItems, g1000VcfFile, m => m.Name, progress);
}
protected virtual EnforceResponse CallEnforcer(IProgressCallback callback)
{
try
{
return m_factory.CreateContentEnforcer(callback).Enforce(m_request, m_response);
}
catch (Exception ex)
{
return HandleException(ex, m_request, "Prompt");
}
}
protected virtual EnforceResponse CallEnforcerForPreview(IProgressCallback callback, Request request, Response response)
{
return m_factory.CreateContentEnforcer(callback).Enforce(request, response);
}
private void InitializeEngine()
{
m_contentScannerEvents = null;
if (null == m_factory)
{
m_factory = new PolicyContent.PolicyEngineFactory();
}
if (!m_bProfilesLoaded)
{
LoadDefaultProfile();
m_bProfilesLoaded = true;
}
}
/// <summary>
/// The load data.
/// </summary>
/// <param name="journeys">
/// The journeys.
/// </param>
/// <param name="loadHistory">
/// The load history.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
public void LoadData(IList<Journey> journeys, bool loadHistory, IProgressCallback callback)
{
this.Logger.DebugFormat("Load data for {0} journeys [{1}]", journeys.Count, loadHistory ? "H" : null);
foreach (var j in journeys)
{
j.Data.Clear();
}
string condition = GenerateCondition(journeys);
using (var connection = new SQLiteConnection(this._connectionString))
{
string selectSql = "SELECT LID, LJOURNEYID, SCURRENCY, BFLIGHT, " + (loadHistory ? "TUPDATE" : "MAX(TUPDATE) TUPDATE")
+ " FROM JOURNEY_DATA " + " WHERE " + condition + (loadHistory ? string.Empty : " GROUP BY (LJOURNEYID)");
using (var getFlightsCmd = new SQLiteCommand(selectSql, connection))
{
connection.Open();
using (var reader = getFlightsCmd.ExecuteReader())
{
if (reader.HasRows)
{
if (reader.HasRows)
{
int iId = reader.GetOrdinal("LID");
int iJourneyId = reader.GetOrdinal("LJOURNEYID");
int iCurrency = reader.GetOrdinal("SCURRENCY");
int iUpdate = reader.GetOrdinal("TUPDATE");
int iFlight = reader.GetOrdinal("BFLIGHT");
while (reader.Read())
{
var flights = this._formatter.FromRaw<List<Flight>>((byte[])reader[iFlight]);
if (flights != null && flights.Count > 0)
{
long dataId = reader.GetInt64(iId);
long journeyId = reader.GetInt64(iJourneyId);
string currency = reader.GetString(iCurrency);
string dataDateStr = reader.GetString(iUpdate);
DateTime dataDate = DateTime.ParseExact(
dataDateStr,
DATETIME_FORMAT,
CultureInfo.InvariantCulture,
DateTimeStyles.AssumeUniversal);
var newData = new JourneyData(dataId, currency, dataDate);
newData.AddFlights(flights);
foreach (var j in journeys)
{
if (j.Id == journeyId)
{
j.AddData(newData);
break;
}
}
}
}
}
}
}
}
}
}
/// <summary>
/// The load data.
/// </summary>
/// <param name="journey">
/// The journey.
/// </param>
/// <param name="loadHistory">
/// The load history.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
public void LoadData(Journey journey, bool loadHistory, IProgressCallback callback)
{
this.LoadData(new List<Journey> { journey }, loadHistory, callback);
}
/// <summary>
/// The validate database.
/// </summary>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="ValidateResult"/>.
/// </returns>
public ValidateResult ValidateDatabase(IProgressCallback callback)
{
this.Logger.Info("Validate database");
string error = null;
using (var connection = new SQLiteConnection(this._connectionString))
{
error = string.Empty;
using (
var getFlightCmd = new SQLiteCommand(@"SELECT COUNT(*) FROM FLIGHT WHERE LJOURNEYID NOT IN (SELECT LID FROM JOURNEY)", connection)
)
{
connection.Open();
object result = getFlightCmd.ExecuteScalar();
long orphanCount;
if (result == null || result is DBNull)
{
orphanCount = 0;
}
else
{
orphanCount = (long)result;
}
if (orphanCount > 0)
{
error = string.Format("There are {0} orphan flights without any assosiated journey detail", orphanCount);
}
}
}
var valResult = new ValidateResult(error == null, error);
return valResult;
}
// Constructor
public CCreatorRecordSource( CGedcom gedcom, IProgressCallback progress, string w3cfile, CSourceRecord sr )
: base(gedcom, progress, w3cfile)
{
m_sr = sr;
}
public static void FindAllele2FrequencyFrom1000GomeByLocus(this IEnumerable <SNPItem> snpItems, string g1000VcfFile, IProgressCallback progress = null)
{
DoFillAllele2FrequencyFrom1000Gome(snpItems, g1000VcfFile, m => string.Format("{0}:{1}", m.Chrom, m.Position), progress);
}
public static IDisposable Work(IProgressCallback callback, int units)
{
if (callback == null)
throw new ArgumentNullException("callback"); // $NON-NLS-1
if (units <= 0)
throw Failure.NegativeOrZero("unit", units);
return new SimpleContext(callback, units);
}
/// <summary>
/// Fill reference allele from genome fasta file.
/// </summary>
/// <param name="snpItems"></param>
/// <param name="fastaFile"></param>
/// <param name="progress"></param>
public static void FillReferenceAlleleFromFasta(this IEnumerable <SNPItem> snpItems, string fastaFile, IProgressCallback progress = null)
{
if (progress == null)
{
progress = new ConsoleProgressCallback();
}
var dic = snpItems.ToGroupDictionary(m => m.Chrom);
progress.SetMessage("Filling reference allele from {0} file ...", fastaFile);
using (var sw = new StreamReader(fastaFile))
{
var ff = new FastaFormat();
Sequence seq;
while ((seq = ff.ReadSequence(sw)) != null)
{
progress.SetMessage("chromosome " + seq.Name + " ...");
var chr = HumanChromosomeToInt(seq.Name);
if (dic.ContainsKey(chr))
{
var snps = dic[chr];
foreach (var snp in snps)
{
snp.RefChar = char.ToUpper(seq.SeqString[snp.Position - 1]);
}
}
}
}
progress.SetMessage("Filling reference allele finished.");
}
public SimpleContext(IProgressCallback c, int u)
{
callback = c; units = u;
}
/// <summary>
/// The reset.
/// </summary>
/// <param name="callback">
/// The callback.
/// </param>
public void Reset(IProgressCallback callback)
{
ProgressDialog.ExecuteTask(
null,
"Initialize new database",
"Please wait...",
"SQLiteDbReset",
ProgressBarStyle.Marquee,
this.Logger,
cb =>
{
cb.Begin();
this.DoResetDatabase(cb);
});
}
/// <summary>
/// The repair database.
/// </summary>
/// <param name="callback">
/// The callback.
/// </param>
public void RepairDatabase(IProgressCallback callback)
{
try
{
this.TryOpenDatabase();
this.Optimize();
}
catch (Exception ex)
{
this.Logger.Error("Failed to optimize database: " + ex);
this.Reset(callback);
}
}
