public ActionResult OsobaHledat(string jmeno, string prijmeni, string narozen)
{
if (Framework.ApiAuth.IsApiAuth(this, "TeamMember").Authentificated)
{
DateTime?dt = ParseTools.ToDateTime(narozen
, "yyyy-MM-dd");
if (dt.HasValue == false)
{
return(Content(Newtonsoft.Json.JsonConvert.SerializeObject(
new { error = "invalid date format. Use yyyy-MM-dd format." }
), "application/json"));
}
var found = Osoba.GetAllByNameAscii(jmeno, prijmeni, dt.Value)
.Select(o => new osobaResult(o))
.ToArray();
return(Content(Newtonsoft.Json.JsonConvert.SerializeObject(
new { Total = found.Count(), Result = found }
), "application/json"));
}
else
{
return(View("Error401"));
}
}
public Direct GetProgram(XmlNode currentProgramXml, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(currentProgramXml);
InlineProgramInfo programInfo = GetInlineProgramInfo(currentProgramXml, parserInfo);
CDFG newProgram = ProgramCDFG.Copy();
TransformCDFGToFunctionCDFG(newProgram, programInfo);
TransformVariableNames(newProgram, programInfo, parserInfo.GetUniquePostFix());
ChangeIDs(newProgram, id);
//Add new variables that this program added
programInfo.OutputsFromTo.ForEach(x => parserInfo.AddVariable(string.Empty, VariableType.FLUID, x.Value));
DFG <Block> nextDFG = XmlParser.ParseNextDFG(currentProgramXml, parserInfo);
DFG <Block> endDFG = newProgram.GetEndDFGInFirstScope();
int i = newProgram.Nodes.FindIndex(x => x.dfg == endDFG);
if (newProgram.Nodes[i].control == null)
{
newProgram.Nodes[i] = (new Direct(nextDFG), endDFG);
}
else
{
newProgram.Nodes[i] = (newProgram.Nodes[i].control.GetNewControlWithNewEnd(nextDFG), endDFG);
}
//merge the programs together nd return the link between then
parserInfo.cdfg.AddCDFG(newProgram);
return(new Direct(newProgram.StartDFG));
}
public ActionResult AddCompanySponzoring(
string ico,
string strana, string rok, string castka, string udalost
)
{
var apires = Framework.ApiAuth.IsApiAuth(this);
if (apires.Authentificated &&
(apires.ApiCall.User == "*****@*****.**" ||
apires.ApiCall.User == "*****@*****.**"
)
)
{
Firma f = Firma.FromIco(ico, true);
if (f == null)
{
HlidacStatu.Util.Consts.Logger.Error("API AddCompanySponzoring: ICO " + ico + " not found");
return(new HttpStatusCodeResult(500, "ICO not found."));
}
f.AddSponsoring(strana, Convert.ToInt32(rok), ParseTools.ToDecimal(castka).Value, "https://udhpsh.cz/5290-2/", this.User.Identity.Name, checkDuplicates: false);
return(Content(Newtonsoft.Json.JsonConvert.SerializeObject(new { ok = true }), "application/json"));
}
else
{
return(new HttpStatusCodeResult(401));
}
}
public void TestSuccesfullConvert()
{
var testCases = new Dictionary <string, object>()
{
{ "some string", "some string" },
{ "\"quote\"", "quote" },
{ "123", 123 },
{ "100", TimeSpan.FromMilliseconds(100) },
{ "23:35", TimeSpan.FromMinutes(23 * 60 + 35) },
{ "23:40", DateTime.Now.Date + TimeSpan.FromMinutes(23 * 60 + 40) },
{ "No", false },
{ "yes", true },
{ "TRUE", true },
{ "false", false },
{ "\"1\"", true },
{ "0", false },
{ "101", (double)101 },
{ "\"103\"", (float)103 },
{ "123,7", (double)123.7 },
{ "123.5", (double)123.5 },
{ "123.555", 123.555M },
{ "124,555", 124.555M },
{ "\"124.5\"", (float)124.5 },
{ "125,5", (float)125.5 },
{ "1", SomeEnum.nino },
{ "THREE", SomeEnum.ThreE },
{ "MsK", SomeEnum.Msk },
};
foreach (var test in testCases)
{
Assert.AreEqual(test.Value, ParseTools.Convert(test.Key, test.Value.GetType(), "arg"));
}
}
public void TestFailConvert()
{
var testCases = new Dictionary <string, Type>()
{
{ "some string", typeof(bool) },
{ "123a", typeof(int) },
{ "\"100", typeof(TimeSpan) },
{ "23:35.123", typeof(TimeSpan) },
{ "hurray!", typeof(DateTime) },
{ "", typeof(int) },
};
foreach (var test in testCases)
{
try{
ParseTools.Convert(test.Key, test.Value, "testArg");
}
catch (InvalidArgumentException ex) {
continue; //This's ok!
}
catch (Exception ex)
{
//And this is not...
Assert.Fail("Exception with incorrect type " + ex.GetType().Name + " raised for " + test.Key + " to " + test.Value.Name + " convertion");
}
//And this...
Assert.Fail("InvalidArgumentException did not raise for " + test.Key + " to " + test.Value.Name + " convertion");
}
}
public ActionResult OsobaPridat(string jmeno, string prijmeni, string narozeni, string titulPred, string titulPo, int typOsoby)
{
var auth = Framework.ApiAuth.IsApiAuth(this, "TeamMember");
if (auth.Authentificated)
{
DateTime?nar = ParseTools.ToDateTimeFromCode(narozeni);
if (nar.HasValue == false)
{
return(Content(Newtonsoft.Json.JsonConvert.SerializeObject(new { valid = false, error = "Invalid date format. Use yyyy-MM-dd format." }), "application/json"));
}
if (typOsoby < 0 || typOsoby > 3)
{
return(Content(Newtonsoft.Json.JsonConvert.SerializeObject(new { valid = false, error = "Invalid typOsoby. Use 0 = NeniPolitik , 1 = ByvalyPolitik , 2 = VazbyNaPolitiky , 3 = Politik." })));
}
var no = Osoba.GetOrCreateNew(titulPred, jmeno, prijmeni, titulPo, nar, (Osoba.StatusOsobyEnum)typOsoby, auth.ApiCall.User);
no.Vazby(true);
return(Content(Newtonsoft.Json.JsonConvert.SerializeObject(
new { valid = true, nameId = no.NameId })
, "application/json"));
}
else
{
return(View("Error401"));
}
}
public static Block Parse(XmlNode node, ParserInfo parseInfo, bool canBeScheduled)
{
string id = ParseTools.ParseID(node);
float value = ParseTools.ParseFloat(node, parseInfo, id);
return(new Constant(value, parseInfo.GetUniqueAnonymousName(), id, canBeScheduled));
}
private void ParseText(Row Row, Span currentSpan, string Text)
{
int CurrentPosition = 0;
bool HasComplex = true;
while (true)
{
ScanResultWord Word = GetNextWord(Text, currentSpan, CurrentPosition,
ref HasComplex);
if (!Word.HasContent)
{
ParseTools.AddString(Text.Substring(CurrentPosition), Row,
currentSpan.spanDefinition.Style, currentSpan);
break;
}
ParseTools.AddString(Text.Substring(CurrentPosition, Word.Position -
CurrentPosition), Row,
currentSpan.spanDefinition.Style, currentSpan);
ParseTools.AddPatternString(Word.Token, Row, Word.Pattern,
Word.ParentList.Style, currentSpan,
false);
CurrentPosition = Word.Position + Word.Token.Length;
}
}
public override string GetInfo()
{
if (showInfo)
{
List <string> list;
list = textureNames.Length > 0 ? ParseTools.ParseNames(textureNames) : ParseTools.ParseNames(mapNames);
textureDisplayList = ParseTools.ParseNames(textureDisplayNames);
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine("Alternate textures available:");
if (Equals(list.Count, 0) && Equals(list.Count, 0))
{
stringBuilder.AppendLine("None");
}
for (int i = 0; i < list.Count; i++)
{
if (i > textureDisplayList.Count - 1)
{
stringBuilder.AppendLine(getTextureDisplayName(list[i]));
}
else
{
stringBuilder.AppendLine(textureDisplayList[i]);
}
}
stringBuilder.AppendLine("\nUse the Next Texture button on the right click menu.");
return(stringBuilder.ToString());
}
return(string.Empty);
}
public ZabHost(string hostId, string host, string url, string description, string[] mainGroup = null)
{
this.hostid = hostId;
this.host = host;
this.url = url;
this.urad = Devmasters.Core.TextUtil.NormalizeToBlockText(ParseTools.GetRegexGroupValue(description, @"Urad:\s?(?<txt>[^\x0a\x0d]*)", "txt"));
this.popis = Devmasters.Core.TextUtil.ShortenHTML(ParseTools.GetRegexGroupValue(description, @"Popis:\s?(?<txt>[^\x0a\x0d]*)", "txt"), 10000, new string[] { "a", "b" });
this.publicname = Devmasters.Core.TextUtil.NormalizeToBlockText(ParseTools.GetRegexGroupValue(description, @"Nazev:\s?(?<txt>[^\x0a\x0d]*)", "txt"));
string sgroup = Devmasters.Core.TextUtil.NormalizeToBlockText(ParseTools.GetRegexGroupValue(description, @"Poznamka:\s?(?<txt>[^\x0a\x0d]*)", "txt"));
this.customUrl = Devmasters.Core.TextUtil.NormalizeToBlockText(ParseTools.GetRegexGroupValue(description, @"URL:\s?(?<txt>[^\x0a\x0d]*)", "txt"));
this.groups.Clear();
if (!string.IsNullOrEmpty(sgroup))
{
var agroups = sgroup.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
this.groups.AddRange(agroups);
}
if (mainGroup != null && mainGroup.Length > 0)
{
this.groups.AddRange(mainGroup);
}
if (string.IsNullOrEmpty(publicname))
{
publicname = this.host;
}
_hash = Devmasters.Core.CryptoLib.Hash.ComputeHashToHex(hostid + "xxttxx" + hostid);
}
public static Block Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
string output = ParseTools.ParseString(node, OUTPUT_FLUID_FIELD_NAME);
Validator.CheckVariableName(id, output);
parserInfo.AddVariable(id, VariableType.FLUID, output);
XmlNode innerNode = node.GetInnerBlockNode(INPUT_FLUID_FIELD_NAME, parserInfo, new MissingBlockException(id, "Fluid is missing fluid definition blocks."));
if (innerNode != null)
{
switch (innerNode.GetAttributeValue(Block.TYPE_FIELD_NAME))
{
case HeaterUsage.XML_TYPE_NAME:
return(HeaterUsage.CreateHeater(output, innerNode, dfg, parserInfo));
case Mixer.XmlTypeName:
return(Mixer.CreateMixer(output, innerNode, dfg, parserInfo));
case Union.XML_TYPE_NAME:
return(Union.CreateUnion(output, innerNode, dfg, parserInfo));
default:
return(CreateFluid(output, innerNode, dfg, parserInfo));
}
}
return(null);
}
public While(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
string mode = node.GetNodeWithAttributeValue(WHILE_MODE_FIELD_NAME).InnerText;
if (mode != SUPPORTED_MODE)
{
parserInfo.ParseExceptions.Add(new ParseException(id, "While block only supports while mode."));
}
XmlNode conditionalNode = node.GetInnerBlockNode(CONDITIONAL_BLOCK_FIELD_NAME, parserInfo, new MissingBlockException(id, "While block is missing its conditional block."));
VariableBlock decidingBlock = null;
if (conditionalNode != null)
{
decidingBlock = (VariableBlock)XmlParser.ParseAndAddNodeToDFG(conditionalNode, dfg, parserInfo);
}
XmlNode guardedNode = node.GetInnerBlockNode(DO_BLOCK_FIELD_NAME, parserInfo, new MissingBlockException(id, "While block is missing blocks to execute."));
if (guardedNode != null)
{
DFG <Block> guardedDFG = XmlParser.ParseDFG(guardedNode, parserInfo);
DFG <Block> nextDFG = XmlParser.ParseNextDFG(node, parserInfo);
this.Cond = new Conditional(decidingBlock, guardedDFG, nextDFG);
}
}
TransactionING GetFromLine(string line)
{
var items = line.Split(';');
_items = items;
int count = items.Length;
if (count != ITEMS_COUNT)
{
return(null);
}
TransactionING transaction = new TransactionING
{
TransactionDate = GetDate(items[0]),
BookingDate = GetDate(items[1]),
CounterPartData = GetStr(items[2]),
AccountNumber = GetAccountNumber(items[4]),
Title = GetStr(items[3]),
Details = GetStr(items[6]),
TransactionNumber = items[7],
Amount = ParseTools.ParseDecimal(items[8]),
Currency = items[9],
BlockAmount = ParseTools.ParseDecimal(items[10]),
Currency2 = items[11],
CurrencyAmount = ParseTools.ParseDecimal(items[12]),
Currency3 = items[13],
AccountName = items[14]
};
return(transaction);
}
public static string NormalizePartyName(string name, string ico)
{
if (_partyNames.TryGetValue(ico, out string normalizedName))
{
return(normalizedName);
}
return(ParseTools.NormalizaceStranaShortName(name));
}
private decimal ParseAmount(string line, StatementItemsPositions positions)
{
var amount = GetValue(line, positions.Castka).Trim();
return(ParseTools.FromTextToDecimal(amount.Trim())
?? throw new ApplicationException(
$"Amount on line '{line}' on position {positions.Castka} could not be read ({amount})"));
}
public ActionResult FindOsobaId(string jmeno, string prijmeni, string narozeni)
{
if (!Framework.ApiAuth.IsApiAuth(this,
parameters: new Framework.ApiCall.CallParameter[] {
new Framework.ApiCall.CallParameter("jmeno", jmeno),
new Framework.ApiCall.CallParameter("prijmeni", prijmeni),
new Framework.ApiCall.CallParameter("narozeni", narozeni)
})
.Authentificated)
{
//Response.StatusCode = 401;
return(Json(ApiResponseStatus.ApiUnauthorizedAccess, JsonRequestBehavior.AllowGet));
}
else
{
DateTime?dt = ParseTools.ToDateTime(narozeni, "yyyy-MM-dd");
if (dt.HasValue == false)
{
var status = ApiResponseStatus.InvalidFormat;
status.error.errorDetail = "invalid date format for parameter 'narozeni'. Use yyyy-MM-dd format.";
return(Json(status, JsonRequestBehavior.AllowGet));
}
var found = HlidacStatu.Lib.StaticData.Politici.Get()
.Where(o =>
string.Equals(o.Jmeno, jmeno, StringComparison.OrdinalIgnoreCase) &&
string.Equals(o.Prijmeni, prijmeni, StringComparison.OrdinalIgnoreCase) &&
o.Narozeni == dt.Value)
.FirstOrDefault();
if (found == null) //try without diacritics
{
string jmenoasc = Devmasters.Core.TextUtil.RemoveDiacritics(jmeno);
string prijmeniasc = Devmasters.Core.TextUtil.RemoveDiacritics(prijmeni);
found = HlidacStatu.Lib.StaticData.Politici.Get()
.Where(o =>
string.Equals(o.JmenoAscii, jmenoasc, StringComparison.OrdinalIgnoreCase) &&
string.Equals(o.PrijmeniAscii, prijmeniasc, StringComparison.OrdinalIgnoreCase) &&
o.Narozeni == dt.Value)
.FirstOrDefault();
}
if (found == null)
{
return(Json(new { }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new
{
Jmeno = found.Jmeno,
Prijmeni = found.Prijmeni,
Narozeni = found.Narozeni.Value.ToString("yyyy-MM-dd"),
OsobaId = found.NameId
}
, JsonRequestBehavior.AllowGet));
}
}
}
public static Block Parse(XmlNode node, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
string moduleName = ParseTools.ParseString(node, MODULE_NAME_FIELD_NAME);
parserInfo.AddVariable(id, VariableType.WASTE, moduleName);
return(new WasteDeclaration(moduleName, parserInfo.GetUniqueAnonymousName(), id));
}
public static Block Parse(XmlNode node, ParserInfo parserInfo, bool canBeScheduled)
{
string id = ParseTools.ParseID(node);
string variableName = ParseTools.ParseString(node, VARIABLE_FIELD_NAME);
parserInfo.CheckVariable(id, VariableType.NUMBER, variableName);
return(new GetNumberVariable(variableName, parserInfo.GetUniqueAnonymousName(), id, canBeScheduled));
}
public static DropletDeclaration Parse(XmlNode node, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
string output = ParseTools.ParseString(node, INPUT_FLUID_FIELD_NAME);
parserInfo.AddVariable(id, VariableType.FLUID, output);
return(new DropletDeclaration(output, id));
}
public static Block Parse(XmlNode node, ParserInfo parserInfo, bool canBeScheduled)
{
string id = ParseTools.ParseID(node);
string arrayName = ParseTools.ParseString(node, ARRAY_NAME_FIELD_NAME);
parserInfo.CheckVariable(id, new VariableType[] { VariableType.NUMBER_ARRAY, VariableType.FLUID_ARRAY }, arrayName);
return(new GetArrayLength(arrayName, parserInfo.GetUniqueAnonymousName(), id, canBeScheduled));
}
public void TestExtractCommandNameWhenNoArgs()
{
var args = new List <string> {
"DiviDe"
};
var cmdName = ParseTools.ExtractCommandName(args);
Assert.AreEqual("divide", cmdName);
Assert.AreEqual(0, args.Count);
}
public static InputDeclaration Parse(XmlNode node, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
float amount = ParseTools.ParseFloat(node, parserInfo, id, INPUT_AMOUNT_FIELD_NAME);
string output = ParseTools.ParseString(node, INPUT_FLUID_FIELD_NAME);
parserInfo.AddVariable(id, VariableType.FLUID, output);
return(new InputDeclaration(output, amount, id));
}
public OsobaEvent AddClenStrany(string strana, int rokOd, int?rokDo, string zdroj, string user)
{
OsobaEvent oe = new OsobaEvent(this.InternalId, string.Format("Člen strany {0}", strana), "", OsobaEvent.Types.ClenStrany);
oe.AddInfo = ParseTools.NormalizaceStranaShortName(strana);
oe.Zdroj = zdroj;
oe.DatumOd = new DateTime(rokOd, 1, 1, 0, 0, 0, DateTimeKind.Local);
oe.DatumDo = rokDo == null ? (DateTime?)null : new DateTime(rokDo.Value, 12, 31, 0, 0, 0, DateTimeKind.Local);
return(AddOrUpdateEvent(oe, user));
}
private static Block CreateFluid(string output, XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
List <FluidInput> inputs = new List <FluidInput>();
inputs.Add(XmlParser.ParseFluidInput(node, dfg, parserInfo));
string id = ParseTools.ParseID(node);
return(new Fluid(inputs, output, id));
}
private void ReadAppSettings()
{
StorageServerServicePath = ServiceUtils.MapConfigPath(ConfigurationManager.AppSettings.Get("storageServerServicePath"));
{
ClientConnection = new PACSConnection();
//the client AE/IP/port used for connecting to remote PACS for query
ClientConnection.AETitle = ConfigurationManager.AppSettings.Get("ClientAe");
if (string.IsNullOrEmpty(ClientConnection.AETitle))
{
ClientConnection.AETitle = "LTCLIENT19";
}
ClientConnection.IPAddress = ConfigurationManager.AppSettings.Get("ClientIP");
if (string.IsNullOrEmpty(ClientConnection.IPAddress))
{
ClientConnection.IPAddress = ServiceUtils.GetLocalIPAddressesV4();
}
ClientConnection.Port = ParseTools.Int(ConfigurationManager.AppSettings.Get("ClientPort"), ServiceUtils.GetFreeIPPort());
}
{
StorageServerConnection = new PACSConnection();
StorageServerConnection.AETitle = ConfigurationManager.AppSettings.Get("ServerAe");
StorageServerConnection.IPAddress = ConfigurationManager.AppSettings.Get("ServerIP");
StorageServerConnection.Port = ParseTools.Int(ConfigurationManager.AppSettings.Get("ServerPort"), -1);
//read default storage server dicom connection settings
if (!string.IsNullOrEmpty(StorageServerServicePath) &&
(string.IsNullOrEmpty(StorageServerConnection.AETitle) ||
string.IsNullOrEmpty(StorageServerConnection.IPAddress) ||
StorageServerConnection.Port <= 0))
{
try
{
var settingsFile = Path.Combine(StorageServerServicePath, "settings.xml");
var doc = XDocument.Load(settingsFile);
{
StorageServerConnection.Port = ParseTools.Int(doc.Descendants("Port").First().Value, -1);
StorageServerConnection.IPAddress = doc.Descendants("IpAddress").First().Value;
StorageServerConnection.AETitle = doc.Descendants("AETitle").First().Value;
}
}
catch
{
}
}
if (string.IsNullOrEmpty(StorageServerConnection.AETitle))
{
StorageServerConnection.AETitle = "LTSTORAGESERVER";
}
}
}
public Task <DownloadInfo> DownloadImages([FromBody] dynamic model)
{
return(impl(model).DownloadImages((string)model.authenticationCookie,
RemoteConnectionFactory.Server(model),
(string)model.client,
(string)model.patientID,
(string)model.studyInstanceUID,
(string)model.seriesInstanceUID,
(string)model.sopInstanceUID,
ParseTools.ToObject <ExtraOptions>(model.extraOptions)));
}
private decimal ParsePrice(string value, DateTime date)
{
var price = ParseTools.ToDecimal(WebUtility.HtmlDecode(value).Replace(" CZK", "").Replace(" ", ""));
if (price.HasValue)
{
return(price.Value);
}
TULogger.Error($"KB: chybejici castka pro ucet {Ucet.CisloUctu} dne {date}");
throw new ApplicationException($"KB: chybejici castka pro ucet {Ucet.CisloUctu} dne {date}");
}
private DateTime ParseDate(string value)
{
var dat = ParseTools.ToDateTime(value, "d. M. yyyy");
if (dat.HasValue)
{
return(dat.Value);
}
TULogger.Error($"KB: chybejici datum pro ucet {Ucet.CisloUctu}");
throw new ApplicationException($"KB: chybejici datum pro ucet {Ucet.CisloUctu}");
}
public ActionResult HledejOsoby(string jmeno, string prijmeni, string narozeni)
{
DateTime?nar = ParseTools.ToDateTime(narozeni, "yyyy-MM-dd");
var osoby = Osoba.GetAllByName(jmeno, prijmeni, nar);
if (osoby.Count() == 0)
{
osoby = Osoba.GetAllByNameAscii(jmeno, prijmeni, nar);
}
return(View(osoby));
}
public static Block Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo, bool canBeScheduled)
{
string id = ParseTools.ParseID(node);
RoundOPTypes roundType = StringToRoundOPType(id, ParseTools.ParseString(node, OPTypeFieldName));
VariableBlock numberBlock = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, NUMBER_FIELD_NAME,
new MissingBlockException(id, "Number defining block is missing."));
dfg.AddNode(numberBlock);
return(new RoundOP(numberBlock, parserInfo.GetUniqueAnonymousName(), roundType, id, canBeScheduled));
}
