private void button1_Click(object sender, EventArgs e)
{
Extract obj = new Extract();
//obj.ExtractFile("E:\\FM9.cab", "E:\\");
//Extract.kHeaderInfo pk = new Extract.kHeaderInfo();
//obj.IsFileCabinet("E:\\FM9.cab",out pk);
StringBuilder s_folder = new StringBuilder();
//obj.ExtractStream(st, s_folder);
// create reader & open file
StreamReader tr = new StreamReader("E:\\FM9.txt");
// read a line of text
while (!tr.EndOfStream)
{
s_folder.AppendLine(tr.ReadLine());
}
// close the stream
tr.Close();
}
internal static Extract ParseToExtractFromFile(XmlTextReader meuXml)
{
var settings = new ParserSettings();
bool temCabecalho = false;
bool temDadosConta = false;
string elementoSendoLido = string.Empty;
Transaction transacaoAtual = null;
BankAccount conta = new BankAccount();
HeaderExtract cabecalho = new HeaderExtract();
Extract extrato = new Extract(cabecalho, conta, "");
try
{
while (meuXml.Read())
{
if (meuXml.NodeType == XmlNodeType.EndElement)
{
switch (meuXml.Name)
{
case "STMTTRN":
if (transacaoAtual != null)
{
extrato.AddTransaction(transacaoAtual);
transacaoAtual = null;
}
break;
}
}
if (meuXml.NodeType == XmlNodeType.Element)
{
elementoSendoLido = meuXml.Name;
switch (elementoSendoLido)
{
case "STMTTRN":
transacaoAtual = new Transaction();
break;
}
}
if (meuXml.NodeType == XmlNodeType.Text)
{
switch (elementoSendoLido)
{
case "DTSERVER":
cabecalho.ServerDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
temCabecalho = true;
break;
case "LANGUAGE":
cabecalho.Language = meuXml.Value;
temCabecalho = true;
break;
case "ORG":
cabecalho.BankName = meuXml.Value;
temCabecalho = true;
break;
case "DTSTART":
extrato.InitialDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
break;
case "DTEND":
extrato.FinalDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
break;
case "BANKID":
conta.Bank = new Bank(GetBankId(meuXml.Value, extrato), "");
temDadosConta = true;
break;
case "BRANCHID":
conta.AgencyCode = meuXml.Value;
temDadosConta = true;
break;
case "ACCTID":
conta.AccountCode = meuXml.Value;
temDadosConta = true;
break;
case "ACCTTYPE":
conta.AccType = meuXml.Value;
temDadosConta = true;
break;
case "TRNTYPE":
transacaoAtual.TrnType = meuXml.Value;
break;
case "DTPOSTED":
transacaoAtual.Date = ConvertOfxDateToDateTime(meuXml.Value, extrato);
break;
case "TRNAMT":
transacaoAtual.Amount = GetTransactionValue(meuXml.Value, extrato);
break;
case "FITID":
transacaoAtual.Id = meuXml.Value;
break;
case "CHECKNUM":
transacaoAtual.Checksum = Convert.ToInt64(meuXml.Value);
break;
case "MEMO":
transacaoAtual.Description = string.IsNullOrEmpty(meuXml.Value) ? "" : meuXml.Value.Trim().Replace(" ", " ");
break;
}
}
}
}
catch (XmlException)
{
throw new FormatException("Invalid OFX file!");
}
finally
{
meuXml.Close();
}
if ((settings.IsValidateHeader && temCabecalho == false) ||
(settings.IsValidateAccountData && temDadosConta == false))
{
throw new FormatException("Invalid OFX file!");
}
return(extrato);
}
public void Visit(Extract node)
{
VisitChild(2, false, false, node.Arguments);
}
/// <inheritdoc/> public override IColumnList GetColumns <TModel>() => Extract.From <TModel>(Table, T.TermRelationships, T.TermTaxonomies);
public void TestInvalid()
{
AnimeResult result = Extract.AnimeNamesFromSite(Helper.LoadFile(@"sites\anime\2.html"));
Assert.AreEqual(AnimeResponse.InvalidId, result.Response);
}
/// <summary>
/// </summary>
/// <param name="blobData"></param>
/// <param name="appContentType"></param>
/// <param name="Base64TokenApplication"></param>
/// <returns></returns>
public OperationResult AssembleTokenApplication(byte[] blobData, out string appContentType, out string Base64TokenApplication)
{
appContentType = null;
Base64TokenApplication = null;
string _tempFolder = null;
Extract _cabExtract = new Extract();
Compress _cabCompress = new Compress();
try
{
_tempFolder = _getTempFolder();
_cabExtract.ExtractFile(_getTemplateFile(), _tempFolder);
_writeBlobFile(_tempFolder, blobData);
_cabCompress.SwitchCompression(false); // pocket´s withdout compression
//_cabCompress.SetEncryptionKey("");
_cabCompress.CompressFolder(_tempFolder, _tempFolder + cAPPFILESYSTEM_NAME, "", true, true, 0x7FFFFFFF);
using (Stream st = File.Open(_tempFolder + cAPPFILESYSTEM_NAME, FileMode.Open, FileAccess.Read))
{
using (BinaryReader br = new BinaryReader(st, Encoding.Default))
{
Base64TokenApplication = Convert.ToBase64String(br.ReadBytes(Convert.ToInt32(br.BaseStream.Length)));
appContentType = cCONTENT_TYPE_NAME;
}
}
return OperationResult.Success;
}
catch
{
Base64TokenApplication = null;
return OperationResult.Error;
}
finally
{
_cabExtract = null;
_cabCompress = null;
if (Directory.Exists(_tempFolder))
Directory.Delete(_tempFolder, true);
}
}
public static void QcDDA(IRawFileThreadManager rawFileThreadManager, WorkflowParameters parameters)
{
MethodDataContainer methodData;
CentroidStreamCollection centroidStreams;
SegmentScanCollection segmentScans;
TrailerExtraCollection trailerExtras;
PrecursorMassCollection precursorMasses;
RetentionTimeCollection retentionTimes;
ScanEventReactionCollection reactions;
var staticRawFile = rawFileThreadManager.CreateThreadAccessor();
staticRawFile.SelectInstrument(Device.MS, 1);
staticRawFile.CheckIfBoxcar();
(ScanIndex Index, PrecursorScanCollection precursorScans, ScanDependentsCollections scanDependents) =
Extract.ScanIndicesPrecursorsDependents(rawFileThreadManager);
using (var rawFile = rawFileThreadManager.CreateThreadAccessor())
{
methodData = Extract.MethodData(rawFile, Index);
reactions = Extract.ScanEvents(rawFile, Index);
(centroidStreams, segmentScans) = Extract.MsData(rawFile: rawFile, index: Index);
trailerExtras = Extract.TrailerExtras(rawFile, Index);
precursorMasses = Extract.PrecursorMasses(rawFile, precursorScans, trailerExtras, Index);
retentionTimes = Extract.RetentionTimes(rawFile, Index);
}
PrecursorPeakCollection peakData = AnalyzePeaks.AnalyzeAllPeaks(centroidStreams, retentionTimes, precursorMasses, precursorScans, Index);
if (parameters.RefineMassCharge)
{
MonoIsoPredictor.RefineMonoIsoMassChargeValues(centroidStreams, precursorMasses, trailerExtras, peakData, precursorScans);
}
ScanMetaDataCollectionDDA metaData = MetaDataProcessingDDA.AggregateMetaDataDDA(centroidStreams, segmentScans, methodData, precursorScans,
trailerExtras, precursorMasses, retentionTimes, scanDependents, reactions, Index);
RawMetricsDataDDA rawMetrics = MetaDataProcessingDDA.GetMetricsDataDDA(metaData, methodData, staticRawFile.FileName, retentionTimes, Index, peakData, precursorScans);
QcDataCollection qcDataCollection = QC.QcWorkflow.LoadOrCreateQcCollection(parameters);
SearchMetricsContainer searchMetrics = new SearchMetricsContainer(staticRawFile.FileName, staticRawFile.CreationDate, methodData);
if (parameters.QcParams.PerformSearch)
{
Search.WriteSearchMGF(parameters, centroidStreams, segmentScans, retentionTimes, precursorMasses, precursorScans, trailerExtras, methodData,
Index, staticRawFile.FileName, parameters.QcParams.FixedScans);
Search.RunSearch(parameters, methodData, staticRawFile.FileName);
searchMetrics = SearchQC.ParseSearchResults(searchMetrics, parameters, staticRawFile.FileName);
}
QcDataContainer qcData = new QcDataContainer();
qcData.DDA = rawMetrics;
qcData.SearchMetrics = searchMetrics;
QC.QcWorkflow.UpdateQcCollection(qcDataCollection, qcData, methodData, staticRawFile.FileName);
staticRawFile.Dispose();
}
private static void ExtractMetadataAsJson(string videoLocalPath, string jsonPath)
{
string json = Extract.ExtractMetadata(videoLocalPath);
System.IO.File.WriteAllText(jsonPath, json);
}
private void Start()
{
stateMachine = new StateMachine();
stateMachine.OnStateEntered += StateMachineOnOnStateEntered;
stateMachine.OnStateExited += StateMachineOnStateExited;
var player = GetComponent <Player>();
var obeliskSelector = new PhysicsLayerStrategy(LayerMask.GetMask("Obelisk"), 1f);
var emptyObeliskMouseSelector = new MouseOverSelector(obeliskSelector, 1, IsObeliskEmpty);
var infusedObeliskMouseSelector = new MouseOverSelector(obeliskSelector, 1, IsObeliskFull);
var idle = new Idle();
var absorb = new Extract(player, infusedObeliskMouseSelector);
var exude = new Infuse(player, emptyObeliskMouseSelector);
var placingObelisk = new PlacingObelisk(obeliskPrefab, player);
var invokeFireElement = new InvokeElement(EssenceNames.Fire);
var invokeWaterElement = new InvokeElement(EssenceNames.Water);
var invokeEarthElement = new InvokeElement(EssenceNames.Earth);
var invokeAirElement = new InvokeElement(EssenceNames.Air);
var buildingFireElement = new Building(emptyObeliskMouseSelector, EssenceNames.Fire);
var buildingWaterElement = new Building(emptyObeliskMouseSelector, EssenceNames.Water);
var buildingEarthElement = new Building(emptyObeliskMouseSelector, EssenceNames.Earth);
var buildingAirElement = new Building(emptyObeliskMouseSelector, EssenceNames.Air);
var attack = new Attack(fireAttack);
stateMachine.AddAnyTransition(placingObelisk, () => PlayerInput.Instance.ObeliskKeyDown);
stateMachine.AddTransition(placingObelisk, idle, () => PlayerInput.Instance.ObeliskKeyDown || placingObelisk.Finished || PlayerInput.Instance.SecondaryActionKeyDown);
stateMachine.AddAnyTransition(absorb, () => PlayerInput.Instance.SecondaryActionKeyDown && player.CurrentEssence == null && absorb.CanExtract);
stateMachine.AddTransition(absorb, idle, () => PlayerInput.Instance.SecondaryActionKeyUp || absorb.Finished);
stateMachine.AddAnyTransition(invokeFireElement, () => PlayerInput.Instance.InvokeFireDown && player.CurrentEssence == null);
stateMachine.AddAnyTransition(invokeWaterElement, () => PlayerInput.Instance.InvokeWaterDown && player.CurrentEssence == null);
stateMachine.AddAnyTransition(invokeEarthElement, () => PlayerInput.Instance.InvokeEarthDown && player.CurrentEssence == null);
stateMachine.AddAnyTransition(invokeAirElement, () => PlayerInput.Instance.InvokeAirDown && player.CurrentEssence == null);
stateMachine.AddTransition(invokeFireElement, idle, () => PlayerInput.Instance.InvokeFireDown || PlayerInput.Instance.SecondaryActionKeyDown);
stateMachine.AddTransition(invokeWaterElement, idle, () => PlayerInput.Instance.InvokeWaterDown || PlayerInput.Instance.SecondaryActionKeyDown);
stateMachine.AddTransition(invokeEarthElement, idle, () => PlayerInput.Instance.InvokeEarthDown || PlayerInput.Instance.SecondaryActionKeyDown);
stateMachine.AddTransition(invokeAirElement, idle, () => PlayerInput.Instance.InvokeAirDown || PlayerInput.Instance.SecondaryActionKeyDown);
stateMachine.AddTransition(invokeFireElement, buildingFireElement, () => CanStartBuilding(emptyObeliskMouseSelector));
stateMachine.AddTransition(invokeWaterElement, buildingWaterElement, () => CanStartBuilding(emptyObeliskMouseSelector));
stateMachine.AddTransition(invokeEarthElement, buildingEarthElement, () => CanStartBuilding(emptyObeliskMouseSelector));
stateMachine.AddTransition(invokeAirElement, buildingAirElement, () => CanStartBuilding(emptyObeliskMouseSelector));
stateMachine.AddTransition(buildingFireElement, invokeFireElement, () => PlayerInput.Instance.PrimaryActionKeyUp || buildingFireElement.Finished);
stateMachine.AddTransition(buildingWaterElement, invokeWaterElement, () => PlayerInput.Instance.PrimaryActionKeyUp || buildingWaterElement.Finished);
stateMachine.AddTransition(buildingEarthElement, invokeEarthElement, () => PlayerInput.Instance.PrimaryActionKeyUp || buildingEarthElement.Finished);
stateMachine.AddTransition(buildingAirElement, invokeAirElement, () => PlayerInput.Instance.PrimaryActionKeyUp || buildingAirElement.Finished);
stateMachine.AddTransition(idle, exude, () => PlayerInput.Instance.PrimaryActionKeyDown && player.CurrentEssence != null && exude.CanInfuse);
stateMachine.AddTransition(exude, idle, () => PlayerInput.Instance.PrimaryActionKeyUp || exude.Finished);
stateMachine.AddTransition(idle, attack, () => PlayerInput.Instance.AttackActionKeyDown && player.CurrentEssence != null);
stateMachine.AddTransition(attack, idle, () => PlayerInput.Instance.AttackActionKeyUp);
stateMachine.SetState(idle);
}
/// <summary>
/// Process specialized
///
/// This is a cheat function to basically force deferred execution to occur.
///
/// All of this sort of late bound meta-data from the system needs to be carefully written to not be too expensive.
/// (e.g. use the .OffsetPos rather than too heavy on dynamic resolution)
///
/// Ensure we have symbols & kernel meta data parsed into our type info
///
/// Also We need vtero.WalkProcList to have been called which isolates vadroot
///
/// </summary>
public void MergeVAMetaData(bool DoStackCheck = false)
{
// setup kernel in optimized scan
ScanAndLoadModules();
// Load as much as possible from full user space scan for PE / load debug data
ScanAndLoadModules("", false, false);
var codeRanges = new ConcurrentDictionary <long, long>();
/// All page table entries
/// including kernel
var execPages = PT.FillPageQueue(false, true);
foreach (var pte in execPages)
{
codeRanges.TryAdd(pte.VA.Address, pte.VA.Address + (pte.PTE.LargePage ? MagicNumbers.LARG_PAGE_SIZE : MagicNumbers.PAGE_SIZE));
}
// Walk Vad and inject into 'sections'
// scan VAD data to additionally bind
ListVad(VadRootPtr);
// Dig all threads
if (DoStackCheck)
{
LoadThreads();
var checkPtrs = new ConcurrentBag <long>();
// instead of using memsections we should use apge table info
// then push in memsection after this round
Parallel.Invoke(() =>
{
// each stack
foreach (var userRange in UserThreadStacks)
{
// every value
foreach (var pointer in userRange.Item2)
{
if (pointer > -4096 && pointer < 4096)
{
continue;
}
// see if in range of code
foreach (var codeRange in codeRanges)
{
// if so we need to double check that the code ptr is a good one
if (pointer >= codeRange.Key && pointer < codeRange.Value)
{
checkPtrs.Add(pointer);
}
}
}
}
}, () =>
{
// each stack
foreach (var kernelRange in ThreadStacks)
{
// every value
foreach (var pointer in kernelRange.Item2)
{
if (pointer > -4096 && pointer < 4096)
{
continue;
}
// see if in range of code
foreach (var codeRange in codeRanges)
{
// if so we need to double check that the code ptr is a good one
if (pointer >= codeRange.Key && pointer < codeRange.Value)
{
checkPtrs.Add(pointer);
}
}
}
}
});
// validate checkPtrs pointers here
// TODO: group pointers so we can minimize page reads
foreach (var ptr in checkPtrs)
{
var idx = ptr & 0xfff;
if (idx < 10)
{
continue;
}
// every pointer needs to be a function start
// or a properly call/ret pair
var ptrTo = VGetBlock(ptr);
//BYTE* bp = (BYTE*)RefFramePtr;
var IsCCBefore = ptrTo[idx - 1];
var IsCallE8 = ptrTo[idx - 5];
var IsCallE8_second = ptrTo[idx - 3];
var IsCall9A = ptrTo[idx - 5];
var IsCall9A_second = ptrTo[idx - 7];
bool FoundFFCode = false;
// scan from RoPCheck
for (int i = 2; i < 10; i++)
{
var a = ptrTo[idx - i];
var b = ptrTo[idx - i + 1];
if (i < 8)
{
if ((a == 0xff) && (b & 0x38) == 0x10)
{
FoundFFCode = true;
break;
}
}
if ((a == 0xff) && (b & 0x38) == 0x18)
{
FoundFFCode = true;
break;
}
}
if (!FoundFFCode && IsCCBefore != 0xcc && IsCallE8 != 0xe8 && IsCallE8_second != 0xe8 && IsCall9A != 0x9a && IsCall9A_second != 0x9a)
{
WriteColor(ConsoleColor.Cyan, $"Stack pointer is wild {ptr:x}");
var cs = Capstone.Dissassemble(ptrTo, ptrTo.Length, (ulong)(ptr & -4096));
for (int i = 0; i < cs.Length; i++)
{
if (cs[i].insn.address == (ulong)ptr)
{
WriteColor(ConsoleColor.Yellow, $"{cs[i - 1].insn.address:x} {cs[i - 1].insn.bytes[0]:x} {cs[i - 1].insn.mnemonic} {cs[i - 1].insn.operands}");
WriteColor(ConsoleColor.Yellow, $"{cs[i].insn.address:x} {cs[i].insn.bytes[0]:x} {cs[i].insn.mnemonic} {cs[i].insn.operands}");
}
}
}
}
}
// find section's with no "Module"
foreach (var sec in Sections.Values)
{
if (sec.Module == null)
{
var test = GetVirtualByte(sec.VadAddr);
var ext = Extract.IsBlockaPE(test);
sec.Module = ext;
}
}
}
private IEnumerable <Extract> DefaultExtracts()
{
var dwhExtracts = _extractRepository.GetAllByEmr(GetDefault().Id, "NDWH").ToList();
var defaultExtracts = new List <Extract>();
foreach (var extract in dwhExtracts)
{
var defaultExtract = new Extract()
{
Id = Guid.NewGuid(),
ExtractSql = "",
Name = extract.Name,
Emr = extract.Emr,
Destination = extract.Destination,
Display = extract.Display,
DocketId = extract.DocketId,
IsPriority = extract.IsPriority,
Rank = extract.Rank
};
defaultExtracts.Add(defaultExtract);
}
var cardExtract = _extractRepository.GetAllByEmr(GetDefault().Id, "PSMART").FirstOrDefault();
if (cardExtract != null)
{
var defaultCardExtract = new Extract()
{
Id = Guid.NewGuid(),
ExtractSql = "",
Name = cardExtract.Name,
Emr = cardExtract.Emr,
Destination = cardExtract.Destination,
Display = cardExtract.Display,
DocketId = cardExtract.DocketId,
IsPriority = cardExtract.IsPriority,
Rank = cardExtract.Rank
};
defaultExtracts.Add(defaultCardExtract);
}
var mpiExtract = _extractRepository.GetAllByEmr(GetDefault().Id, "CBS").FirstOrDefault();
if (mpiExtract != null)
{
var defaultMpiExtract = new Extract()
{
Id = Guid.NewGuid(),
ExtractSql = "",
Name = mpiExtract.Name,
Emr = mpiExtract.Emr,
Destination = mpiExtract.Destination,
Display = mpiExtract.Display,
DocketId = mpiExtract.DocketId,
IsPriority = mpiExtract.IsPriority,
Rank = mpiExtract.Rank
};
defaultExtracts.Add(defaultMpiExtract);
}
var htsExtract = _extractRepository.GetAllByEmr(GetDefault().Id, "HTS").ToList();
foreach (var extract in htsExtract)
{
var defaultExtract = new Extract()
{
Id = Guid.NewGuid(),
ExtractSql = "",
Name = extract.Name,
Emr = extract.Emr,
Destination = extract.Destination,
Display = extract.Display,
DocketId = extract.DocketId,
IsPriority = extract.IsPriority,
Rank = extract.Rank
};
defaultExtracts.Add(defaultExtract);
}
return(defaultExtracts);
}
public async Task <IActionResult> Save([Bind("Format", "FacilityID", "ExtractionDate", "DocumentationViewID", "ContactName", "Address1", "Address2", "City", "State", "ZipCode")] Extract extract)
{
if (ModelState.IsValid)
{
string newPassword;
//Check if there's another extract. This way we should get CSV and PDF extracts to share same randomly generated password.
var currentExtract = await _sayonaraContext.Extracts
.Where(e => e.FacilityID == extract.FacilityID)
.OrderByDescending(e => e.ExtractionDate)
.FirstOrDefaultAsync();
if (currentExtract != null)
{
newPassword = currentExtract.Password;
}
else
{
newPassword = Utilities.PasswordGenerator.Generate(20);
}
_sayonaraContext.Extracts.Add(new Extract
{
PublicID = System.Guid.NewGuid(),
FacilityID = extract.FacilityID,
ExtractionDate = extract.ExtractionDate,
Format = extract.Format,
DocumentationViewID = extract.DocumentationViewID,
Status = Extract.NotStartedStatus,
TotalCount = 0,
CurrentCount = 0,
Password = newPassword,
CreatedBy = User.Identity.Name,
ContactName = extract.ContactName,
Address1 = extract.Address1,
Address2 = extract.Address2,
City = extract.City,
State = extract.State,
ZipCode = extract.ZipCode
});
_sayonaraContext.SaveChanges();
return(View("Index", _sayonaraContext.Extracts
.Include(e => e.Facility)
.ThenInclude(f => f.DocumentationViews)
.OrderByDescending(e => e.ExtractionDate)
.ToList()));
}
else
{
if (extract.FacilityID == 0)
{
ViewBag.ErrorMessage = "A Facility needs to be chosen";
return(View("Add"));
}
if (extract.ExtractionDate <= System.DateTime.Now.AddDays(-2)) //-2 because I think the azure website deployed is an an unknow timezone
{
ViewBag.ErrorMessage = "Extraction date needs to be chosen and in the future!";
return(View("Add"));
}
ViewBag.ErrorMessage = "An unknown problem with your selections occured.";
return(View("Add"));
}
}
public static ResolvableConstraintExpression Calls([NotNull] this ResolvableConstraintExpression expression, [NotNull] Expression <Action> call, string functionName = null)
{
expression.Append(new CallToConstraint(Extract.BindingInfoFrom(call), functionName));
return(expression);
}
public Extract GenerateExtract(string ofxSourceFile)
{
// Translating to XML file
var xmlFilePath = ofxSourceFile + ".xml";
ExportToXml(ofxSourceFile, xmlFilePath);
var elementoSendoLido = "";
Transaction transacaoAtual = null;
var header = new HeaderExtract();
var bankAccount = new BankAccount();
var extract = new Extract(header, bankAccount, "");
// Lendo o XML efetivamente
var xmlReader = new XmlTextReader(xmlFilePath);
try
{
while (xmlReader.Read())
{
if (xmlReader.NodeType == XmlNodeType.EndElement && xmlReader.Name.Equals("STMTTRN") && transacaoAtual != null)
{
extract.AddTransaction(transacaoAtual);
transacaoAtual = null;
}
if (xmlReader.NodeType == XmlNodeType.Element)
{
elementoSendoLido = xmlReader.Name;
if (xmlReader.Name.Equals("STMTTRN"))
{
transacaoAtual = new Transaction();
}
}
if (xmlReader.NodeType == XmlNodeType.Text)
{
switch (elementoSendoLido)
{
case "DTSERVER":
header.ServerDate = ConvertOfxDateToDateTime(xmlReader.Value, extract);
break;
case "LANGUAGE":
header.Language = xmlReader.Value;
break;
case "ORG":
header.BankName = xmlReader.Value;
break;
case "DTSTART":
extract.InitialDate = ConvertOfxDateToDateTime(xmlReader.Value, extract);
break;
case "DTEND":
extract.FinalDate = ConvertOfxDateToDateTime(xmlReader.Value, extract);
break;
case "BANKID":
bankAccount.Bank = new Bank(GetBankId(xmlReader.Value, extract), "");
break;
case "BRANCHID":
bankAccount.AgencyCode = xmlReader.Value;
break;
case "ACCTID":
bankAccount.AccountCode = xmlReader.Value;
break;
case "ACCTTYPE":
bankAccount.Type = xmlReader.Value;
break;
case "TRNTYPE":
transacaoAtual.Type = xmlReader.Value;
break;
case "DTPOSTED":
transacaoAtual.Date = ConvertOfxDateToDateTime(xmlReader.Value, extract);
break;
case "TRNAMT":
transacaoAtual.TransactionValue = GetTransactionValue(xmlReader.Value, extract);
break;
case "FITID":
transacaoAtual.Id = xmlReader.Value;
break;
case "CHECKNUM":
transacaoAtual.Checksum = Convert.ToInt64(xmlReader.Value);
break;
case "MEMO":
transacaoAtual.Description = string.IsNullOrEmpty(xmlReader.Value) ? string.Empty : Regex.Replace(xmlReader.Value.Trim(), "[^\\S\\n]+", " ");
break;
}
}
}
}
catch (XmlException xe)
{
throw new OFXParserException($"Invalid OFX file", xe);
}
finally
{
xmlReader.Close();
}
return(extract);
}
public static Extract GetExtract(String ofxSourceFile, ParserSettings settings)
{
if (settings == null)
{
settings = new ParserSettings();
}
Boolean temCabecalho = false;
Boolean temDadosConta = false;
// Translating to XML file
ExportToXml(ofxSourceFile, ofxSourceFile + ".xml");
// Variáveis úteis para o Parse
String elementoSendoLido = "";
Transaction transacaoAtual = null;
// Variávies utilizadas para a leitura do XML
HeaderExtract cabecalho = new HeaderExtract();
BankAccount conta = new BankAccount();
Extract extrato = new Extract(cabecalho, conta, "");
// Lendo o XML efetivamente
XmlTextReader meuXml = new XmlTextReader(ofxSourceFile + ".xml");
try
{
while (meuXml.Read())
{
if (meuXml.NodeType == XmlNodeType.EndElement)
{
switch (meuXml.Name)
{
case "STMTTRN":
if (transacaoAtual != null)
{
extrato.AddTransaction(transacaoAtual);
transacaoAtual = null;
}
break;
}
}
if (meuXml.NodeType == XmlNodeType.Element)
{
elementoSendoLido = meuXml.Name;
switch (elementoSendoLido)
{
case "STMTTRN":
transacaoAtual = new Transaction();
break;
}
}
if (meuXml.NodeType == XmlNodeType.Text)
{
switch (elementoSendoLido)
{
case "DTSERVER":
cabecalho.ServerDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
temCabecalho = true;
break;
case "LANGUAGE":
cabecalho.Language = meuXml.Value;
temCabecalho = true;
break;
case "ORG":
cabecalho.BankName = meuXml.Value;
temCabecalho = true;
break;
case "DTSTART":
extrato.InitialDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
break;
case "DTEND":
extrato.FinalDate = ConvertOfxDateToDateTime(meuXml.Value, extrato);
break;
case "BANKID":
conta.Bank = new Bank(GetBankId(meuXml.Value, extrato), "");
temDadosConta = true;
break;
case "BRANCHID":
conta.AgencyCode = meuXml.Value;
temDadosConta = true;
break;
case "ACCTID":
conta.AccountCode = meuXml.Value;
temDadosConta = true;
break;
case "ACCTTYPE":
conta.Type = meuXml.Value;
temDadosConta = true;
break;
case "TRNTYPE":
transacaoAtual.Type = meuXml.Value;
break;
case "DTPOSTED":
transacaoAtual.Date = ConvertOfxDateToDateTime(meuXml.Value, extrato);
break;
case "TRNAMT":
transacaoAtual.TransactionValue = GetTransactionValue(meuXml.Value, extrato);
break;
case "FITID":
transacaoAtual.Id = meuXml.Value;
break;
case "CHECKNUM":
transacaoAtual.Checksum = Convert.ToInt64(meuXml.Value);
break;
case "MEMO":
transacaoAtual.Description = string.IsNullOrEmpty(meuXml.Value) ? "" : meuXml.Value.Trim().Replace(" ", " ");
break;
case "NAME":
transacaoAtual.Name = string.IsNullOrEmpty(meuXml.Value) ? "" : meuXml.Value.Trim().Replace(" ", " ");
break;
}
}
}
}
catch (XmlException xe)
{
throw new OFXParserException("Invalid OFX file!");
}
finally
{
meuXml.Close();
}
if ((settings.IsValidateHeader && temCabecalho == false) ||
(settings.IsValidateAccountData && temDadosConta == false))
{
throw new OFXParserException("Invalid OFX file!");
}
return(extrato);
}
public void Save(Extract extract)
{
_extractRepository.CreateOrUpdate(extract);
_extractRepository.SaveChanges();
}
public void ReadXml(XmlReader reader, Extract extract)
{
// <xs:extension base="LOCATABLE">
this.ReadXmlBase(reader, extract as ExtractLocatable);
// <xs:element name="request_id" type="OBJECT_REF" minOccurs="0"/>
if (reader.LocalName == "request_id")
{
if (reader.HasAttributes)
{
throw new NotSupportedException("subtype of OBJECT_REF not supported in request_id");
}
extract.RequestId = new ObjectRef();
extract.RequestId.ReadXml(reader);
}
// <xs:element name="time_created" type="DV_DATE_TIME"/>
Check.Require(reader.LocalName == "time_created", "time_created is mandatory");
extract.TimeCreated = new DvDateTime();
extract.TimeCreated.ReadXml(reader);
// <xs:element name="system_id" type="HIER_OBJECT_ID"/>
Check.Require(reader.LocalName == "system_id", "system_id is mandatory");
extract.SystemId = new HierObjectId();
extract.SystemId.ReadXml(reader);
// <xs:element name="partitipations" type="PARTICIPATION" minOccurs="0" maxOccurs="unbounded"/>
if (reader.Name == "partitipations")
{
extract.Participations = new OpenEhr.AssumedTypes.List <Participation>();
}
while (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name == "partitipations")
{
Participation participation = new Participation();
participation.ReadXml(reader);
extract.Participations.Add(participation);
}
// <xs:element name="sequence_nr" type="xs:long"/>
extract.SequenceNr = reader.ReadElementContentAsInt("sequence_nr", RmXmlSerializer.OpenEhrNamespace);
reader.MoveToContent();
// <xs:element name="chapters" type="EXTRACT_CHAPTER" minOccurs="0" maxOccurs="unbounded"/>
if (reader.Name == "chapters")
{
extract.Chapters = new OpenEhr.AssumedTypes.List <ExtractChapter>();
}
while (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name == "chapters")
{
ExtractChapter chapter = new ExtractChapter();
this.ReadXml(reader, chapter);
extract.Chapters.Add(chapter);
}
// TODO: <xs:element name="specification" type="EXTRACT_SPEC" minOccurs="0"/>
if (reader.Name == "specification")
{
throw new NotImplementedException("specification not implemented");
}
reader.ReadEndElement();
reader.MoveToContent();
}
public bool Verfiy(Extract extract, DatabaseProtocol databaseProtocol)
{
return(_databaseManager.VerifyQuery(extract, databaseProtocol));
}
/// <summary>
/// Default window loaded event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Window_Loaded(object sender, RoutedEventArgs e)
{
#region Basic API definitaions
// api key for app authorization
Api.API_KEY = Core.Configs.API_KEY;
// api secret for client authorization
Api.API_SECRET = Core.Configs.API_SECRET;
// select output type
Api.OutputType = Api.OutputTypes.Json;
#endregion
// define Updater class and set credentials
KOR.Updater.Core.Updater updater = new KOR.Updater.Core.Updater
{
// app versions stores sqlite database
AppVersion = dbprocs.GetAppVersion(),
// listing multi results off
MultiResult = false
};
// check update
var checkresult = updater.CheckUpdate();
// if there is update/s
if ((bool)checkresult == true)
{
// if there is listed update/s
if (updater.Updates.Count > 0)
{
// create new thread and start extracting file
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
foreach (var update in updater.Updates)
{
#region Backup Block
Application.Current.Dispatcher.Invoke(new Action(() =>
{
Status.Text = "Starting backup process...";
}));
Thread.Sleep(1500);
// prepare backup
Backup backup = new Backup
{
// maximum compression
// might be hard some CPUs
CompressionLevel = 9,
// set backup store folder path
BackupStoreFolder = AppDomain.CurrentDomain.BaseDirectory + "backup",
// which folder and contains includes
BackupFolder = AppDomain.CurrentDomain.BaseDirectory
};
// ignore backup "/backup" folder
backup.IgnoreDirs.Add(new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory + "backup"));
// ignore backup downloaded update
//backup.IgnoreFiles.Add(new FileInfo(download.DownloadFilePath));
// start backup
backup.CreateBackup();
if (backup.BackupState)
{
Application.Current.Dispatcher.Invoke(new Action(() =>
{
Status.Text = "Backup created successfully. Now starting download new updated.";
}));
Thread.Sleep(1500);
}
#endregion
#region Download Block
// prepare downloading
Download download = new Download
{
// set download url
DownloadUrl = new Uri(update.DownloadUrl),
DownloadFileName = Path.GetFileName(update.DownloadUrl),
DownloadFilePath = AppDomain.CurrentDomain.BaseDirectory + Path.GetFileName(update.DownloadUrl),
};
// time needs download progress
Timer.Start();
// start downloading
download.DownloadUpdate();
// when download finished
if (download.DownloadFinished)
{
Timer.Stop();
}
#endregion
#region Extract Block
// if downloaded file is .zip file
if (Path.GetExtension(download.DownloadFileName) == ".zip")
{
Application.Current.Dispatcher.Invoke(new Action(() =>
{
Status.Text = "Extracting update...";
}));
Thread.Sleep(1500);
// prepare extraction
Extract extract = new Extract
{
FilePath = download.DownloadFilePath,
OutputFolder = AppDomain.CurrentDomain.BaseDirectory
};
// extract file
extract.ExtractZipFile();
}
#endregion
#region Final Block
// send operation results
Reporter reporter = new Reporter
{
Downloaded = true,
Success = true
};
// send report
reporter.SendReport(update.UpdateId);
// update version info new version value and save last update info
dbprocs.UpdateVersionString(update.AppVersion, update.UpdateId, update.AddedFeatures, update.RemovedFeatures, update.ReasonCode, update.ReasonTitle);
#endregion
Application.Current.Dispatcher.Invoke(new Action(() =>
{
Status.Text = "Your application updated!";
// and then go next step, what you want
// start main app and close this updated
Process.Start(AppDomain.CurrentDomain.BaseDirectory + "Poli.Makro");
Environment.Exit(Environment.ExitCode);
}));
}
}).Start();
// loop in updates
}
}
else if ((bool)checkresult == false)
{
// if there is not update
MessageBox.Show("You application is up to date.");
if (!string.IsNullOrEmpty(updater.UpdaterResponse.ResponseAPIErrorMessage))
{
MessageBox.Show(updater.UpdaterResponse.ResponseAPIErrorMessage, "Error:", MessageBoxButton.OK, MessageBoxImage.Error);
}
else if (!string.IsNullOrEmpty(updater.UpdaterResponse.ResponseAPIWarningMessage))
{
MessageBox.Show(updater.UpdaterResponse.ResponseAPIWarningMessage, "Warning:", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
else if (checkresult == null)
{
// possible no internet connection
MessageBox.Show("There is no internet connection.");
}
}
public Extract Update(Extract extract)
{
_extractRepository.Update(extract);
_extractRepository.SaveChanges();
return(extract);
}
public static void ParseDDA(IRawFileThreadManager rawFileThreadManager, WorkflowParameters parameters)
{
MethodDataContainer methodData;
CentroidStreamCollection centroidStreams;
SegmentScanCollection segmentScans;
TrailerExtraCollection trailerExtras;
PrecursorMassCollection precursorMasses;
RetentionTimeCollection retentionTimes;
ScanEventReactionCollection reactions;
ScanMetaDataCollectionDDA metaData = null;
PrecursorPeakCollection peakData = null;
RawMetricsDataDDA rawMetrics = null;
QuantDataCollection quantData = null;
var staticRawFile = rawFileThreadManager.CreateThreadAccessor();
staticRawFile.SelectInstrument(Device.MS, 1);
//staticRawFile.CheckIfBoxcar();
(ScanIndex Index, PrecursorScanCollection precursorScans, ScanDependentsCollections scanDependents) =
Extract.ScanIndicesPrecursorsDependents(rawFileThreadManager);
using (var rawFile = rawFileThreadManager.CreateThreadAccessor())
{
reactions = Extract.ScanEvents(rawFile, Index);
methodData = Extract.MethodData(rawFile, Index);
(centroidStreams, segmentScans) = Extract.MsData(rawFile: rawFile, index: Index);
trailerExtras = Extract.TrailerExtras(rawFile, Index);
precursorMasses = Extract.PrecursorMasses(rawFile, precursorScans, trailerExtras, Index);
retentionTimes = Extract.RetentionTimes(rawFile, Index);
}
if (parameters.ParseParams.Parse | parameters.ParseParams.Quant | parameters.ParseParams.Metrics | parameters.RefineMassCharge)
{
peakData = AnalyzePeaks.AnalyzeAllPeaks(centroidStreams, retentionTimes, precursorMasses, precursorScans, Index);
if (parameters.RefineMassCharge)
{
MonoIsoPredictor.RefineMonoIsoMassChargeValues(centroidStreams, precursorMasses, trailerExtras, peakData, precursorScans);
}
metaData = MetaDataProcessingDDA.AggregateMetaDataDDA(centroidStreams, segmentScans, methodData, precursorScans,
trailerExtras, precursorMasses, retentionTimes, scanDependents, reactions, Index);
}
if (parameters.ParseParams.Quant)
{
quantData = Quantification.Quantify(centroidStreams, segmentScans, parameters, methodData, Index);
}
if (parameters.ParseParams.Metrics)
{
rawMetrics = MetaDataProcessingDDA.GetMetricsDataDDA(metaData, methodData, staticRawFile.FileName, retentionTimes, Index, peakData, precursorScans, quantData);
MetricsWriter.WriteMatrix(rawMetrics, null, staticRawFile.FileName, parameters.ParseParams.OutputDirectory);
}
if (parameters.ParseParams.Parse | parameters.ParseParams.Quant)
{
string matrixFileName = ReadWrite.GetPathToFile(parameters.ParseParams.OutputDirectory, staticRawFile.FileName, "_Matrix.txt");
/*
* ParseWriter writerDDA = new ParseWriter(matrixFileName, centroidStreams, segmentScans, metaData, retentionTimes,
* precursorMasses, precursorScans, peakData, trailerExtras, Index, quantData);
* writerDDA.WriteMatrixDDA(methodData.AnalysisOrder);
*/
MatrixWriter.ParseQuantDDA(matrixFileName, centroidStreams, segmentScans, metaData, retentionTimes,
precursorMasses, precursorScans, peakData, trailerExtras, Index, quantData);
}
if (parameters.ParseParams.WriteMgf)
{
//ParseWriter writerMGF = new ParseWriter(centroidStreams, segmentScans, parameters, retentionTimes, precursorMasses, precursorScans, trailerExtras, methodData, Index);
//writerMGF.WriteMGF(staticRawFile.FileName);
MgfWriter.WriteMGF(staticRawFile.FileName, centroidStreams, segmentScans, parameters, retentionTimes, precursorMasses, precursorScans, trailerExtras, methodData, Index);
}
if (parameters.ParseParams.Chromatogram != null)
{
ChromatogramWriter.WriteChromatogram(centroidStreams, segmentScans, retentionTimes, methodData, Index, parameters, staticRawFile.FileName);
}
}
public static InjectedPluginInfo InjectAssembly(Assembly assembly, Service service = null)
{
Assembly = assembly;
if (assembly is null)
{
throw new ArgumentNullException("assembly");
}
if (service is null)
{
service = Service.GetService();
}
if (service is null)
{
throw new ArgumentNullException("service has not started");
}
var script = service.GetScript();
var ipi = new InjectedPluginInfo();
foreach (var c in Extract.GetPluginContainers(new[] { assembly }))
{
try {
var Container = NUMC.Plugin.Container.CreateContainer(c);
ipi.Containers.Add(Container);
var bt = Container.BaseType;
if (bt == typeof(IRuntime))
{
var scriptRuntimes = script?.GetRuntimes();
if (scriptRuntimes is object)
{
foreach (IRuntime item in Container.Plugins)
{
scriptRuntimes.Add(item);
}
}
else
{
ipi.Exceptions.Add(new ArgumentNullException(
"runtime of the script is incorrect"));
}
}
else if (bt == typeof(IApplicationMenu))
{
var appMenus = service.GetApplicationMenus();
foreach (IApplicationMenu item in Container.Plugins)
{
appMenus.Add(item);
}
}
else if (bt == typeof(INotifyMenu))
{
var notifyMenus = service.GetNotifyMenus();
foreach (INotifyMenu item in Container.Plugins)
{
notifyMenus.Add(item);
}
}
else if (bt == typeof(IKeyMenu))
{
var keyMenus = service.GetKeyMenus();
foreach (IKeyMenu item in Container.Plugins)
{
keyMenus.Add(item);
}
}
else
{
ipi.Exceptions.Add(new NotSupportedException("this plugin is not supported"));
}
if (Container.BaseType.GetInterface(typeof(IPluginExp).Name) == typeof(IPluginExp))
{
foreach (IPluginExp item in Container.Plugins)
{
item.Initialize(script);
}
}
service.GetMain().ReloadLanguage();
} catch (Exception ex) {
ipi.Exceptions.Add(ex);
}
}
return(ipi);
}
public static List<IComparable> ParseAll(String input,Extract[] parsers)
{
int count = 0;
IComparable[][] alloc = new IComparable[parsers.Length][];
for (int i = 0; i < parsers.Length; i++)
{
if (parsers[i](input) != null)
{
alloc[i] = parsers[i](input);
count += alloc[i].Length;
}
}
List<IComparable> res = new List<IComparable>();
for (int i = 0; i < parsers.Length; i++)
{
if (alloc[i] != null)
{
res.AddRange(alloc[i]);
count -= alloc[i].Length;
}
}
return res;
}
public void TestEmpty()
{
AnimeResult result = Extract.AnimeNamesFromSite("");
Assert.AreEqual(AnimeResponse.Unknown, result.Response);
}
