public void Start(call step)
{
try
{
var s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var ip = IPAddress.Parse("178.79.188.184");
var endPoint = new IPEndPoint(ip, 51337);
s.Connect(endPoint);
led.Write(true);
var data = new byte[1];
while (true)
{
if (s.Available > 0)
{
s.Receive(data);
if(data[0] == 10)
step.Invoke();
}
else
{
Thread.Sleep(100);
}
}
s.Close();
}
catch (Exception ex)
{
led.Write(false);
Debug.Print(ex.Message);
}
}
public void JoinCall()
{
if (Connected == null)
{
throw new MissingEventException("Connected");
}
else
{
//get info
string data;
while (true)
{
if (Server.CanRequest)
{
using HttpClient web = new();
web.DefaultRequestHeaders.Add("token", Server.Token);
web.DefaultRequestHeaders.Add("id", Channel.ToString());
data = web.GetAsync($"https://{Server.Domain}/Luski/api/{Server.API_Ver}/GetCallInfo").Result.Content.ReadAsStringAsync().Result;
break;
}
}
IncomingHTTP json = JsonSerializer.Deserialize <IncomingHTTP>(data);
call c = JsonSerializer.Deserialize <call>(json.data.ToString());
Server.ServerOut.Send(JsonRequest.Send(DataType.Join_Call, JsonRequest.JoinCall(Channel)).ToString());
Samples = c.samples;
}
}
public XmsCall(string a_callId)
{
this.CallId = a_callId;
m_call = new call();
m_call_action = new call_action();
m_play = new play();
m_playrec = new playrecord();
m_playcollect = new playcollect();
}
public XmsCall(string a_callId)
{
this.CallId = a_callId;
m_call = new call();
m_call_action = new call_action();
m_play = new play();
m_playrec = new playrecord();
m_playcollect = new playcollect();
}
internal void Set(webCall.call webCall, socketBase socket, domainServer domainServer, long socketIdentity, requestHeader request, call call)
{
this.webCall = webCall;
this.socket = socket;
this.domainServer = domainServer;
this.SocketIdentity = socketIdentity;
this.request = request;
this.call = call;
}
public CallQuestionAnswerDisplay(question q, choice c, call ca)
{
InitializeComponent();
_question = q;
_choice = c;
_currentCall = ca;
lblDataDescription.Text = q.text;
SetQuestion();
}
private void push()
{
webCall = null;
socket = null;
domainServer = null;
request = null;
form = null;
call = null;
typePool <loader> .PushNotNull(this);
}
public void Show(string str, call ok = null, call cancel = null)
{
mb_tt.text = str;
g_ok = ok;
g_cancel = cancel;
if (Module.UI.mask)
{
Module.UI.mask.OnClick = Hide;
Module.UI.mask.Enable(true);
Module.UI.mask.gameObject.SetActive(true);
}
gameObject.SetActive(true);
}
public MessageResult Save(callModel model)
{
MessageResult result = new MessageResult();
try
{
using (CallITEntities db = new CallITEntities())
{
call md = new call();
md.machineName = model.machineName;
md.machineIP = model.machineIP;
md.sendDatetime = model.sendDatetime;
md.sendName = model.sendName;
md.sendText = model.sendText;
md.sendTel = model.sendTel;
db.call.Add(md);
db.SaveChanges();
result.status = "success";
}
}
catch (DbEntityValidationException exp)
{
foreach (var entityValidationErrors in exp.EntityValidationErrors)
{
foreach (var validationError in entityValidationErrors.ValidationErrors)
{
Console.WriteLine("Property: {0} Error: {1}",
validationError.PropertyName, validationError.ErrorMessage);
}
}
result.status = "error";
}
return(result);
}
/// <summary>
/// Creates a new version of a model from a trained TensorFlow model.
If the version created in the cloud by this call is the first deployed
public static void GoImport()
{
claim workingClaim = new claim();
DataTable importData = new DataTable();
DataTable importDataSecondaries = new DataTable();
DataTable importDataPredeterms = new DataTable();
DataTable importDataSecondaryPredeterms = new DataTable();
system_options.SetImportFlag(true);
primaryClaimCount = 0;
secondaryClaimCount = 0;
predetermClaimCount = 0;
secondaryPredetermClaimCount = 0;
closedClaimCount = 0;
OleDbConnection oConnect;
//UpdateProgressBar(50, "Initiating Remote Connection...");
#region Initiate Connection, Get Data
try
{
oConnect = new OleDbConnection(dms.GetConnectionString(true));
}
catch (Exception err)
{
CreateLogFile(err.ToString());
Updateimporterror(true);
DeleteDirectoryFromTemp();
//LoggingHelper.Log("An error occurred getting the connection string for a new connection in frmImportData.Import", LogSeverity.Error, err, false);
//e.Cancel = true;
CancelImport();
return;
}
OleDbDataAdapter oAdapter;
// Use Connection object for the DataAdapter to retrieve all tables from selected Database
try
{
oConnect.Open();
}
catch (Exception err)
{
CreateLogFile(err.ToString());
Updateimporterror(true);
DeleteDirectoryFromTemp();
//LoggingHelper.Log("Could not connect to the database in frmImportdata.Import", LogSeverity.Error, err, false);
//e.Cancel = true;
CancelImport();
return;
}
try
{
//UpdateProgressBar(50, "Querying remote database (Standard)...");
// ************* Standard Claims
oAdapter = new OleDbDataAdapter(PrepareSQL(dms.sqlstatement, changesOnly), oConnect);
oAdapter.SelectCommand.CommandTimeout = System.Convert.ToInt32(dataTimeout);
oAdapter.Fill(importData);
//UpdateProgressBar(10, "Querying remote database (Secondary)...");
// ************** Secondaries
if (dms.sqlstatementsecondaries != "")
{
oAdapter = new OleDbDataAdapter(PrepareSQL(dms.sqlstatementsecondaries, changesOnly), oConnect);
oAdapter.SelectCommand.CommandTimeout = System.Convert.ToInt32(dataTimeout);
oAdapter.Fill(importDataSecondaries);
}
//UpdateProgressBar(10, "Querying remote database (Predeterms)...");
// *************** Predeterms
if (dms.sqlstatementpredeterms != "")
{
oAdapter = new OleDbDataAdapter(PrepareSQL(dms.sqlstatementpredeterms, changesOnly), oConnect);
oAdapter.SelectCommand.CommandTimeout = System.Convert.ToInt32(dataTimeout);
oAdapter.Fill(importDataPredeterms);
}
//UpdateProgressBar(10, "Querying remote database (Secondary Predeterms)...");
// *************** Predeterms
if (dms.sqlstatementsecondarypredeterms != "")
{
oAdapter = new OleDbDataAdapter(PrepareSQL(dms.sqlstatementsecondarypredeterms, changesOnly), oConnect);
oAdapter.SelectCommand.CommandTimeout = System.Convert.ToInt32(dataTimeout);
oAdapter.Fill(importDataSecondaryPredeterms);
}
}
catch (Exception err)
{
CreateLogFile(err.ToString());
Updateimporterror(true);
DeleteDirectoryFromTemp();
//LoggingHelper.Log("Error with SQL statement or connection in frmImportData.Import", LogSeverity.Error, err);
//MessageBox.Show(this, "There was an error with your SQL statement or with your connection.\n\n" + err.Message,
// "Error retrieving data");
CancelImport();
return;
}
#endregion
data_mapping_schema_data dmsd = new data_mapping_schema_data();
dmsd.schema_id = dms.id;
DataTable dataForSchema = dmsd.Search();
// Generate our list of objects one time, and then use them for each iteration of rows
List <data_mapping_schema_data> allMappedSchemaData = new List <data_mapping_schema_data>();
foreach (DataRow aMapping in dataForSchema.Rows)
{
// For every row, need to get the data for every field
dmsd = new data_mapping_schema_data();
dmsd.Load(aMapping);
allMappedSchemaData.Add(dmsd);
}
// UpdateProgressBar(100, "Importing data...");
if (okToZap)
{
company cmp = new company();
cmp.Zap();
workingClaim.Zap();
call aCall = new call();
aCall.Zap();
company_contact_info info = new company_contact_info();
info.Zap();
procedure p = new procedure();
p.Zap();
choice c = new choice();
c.Zap();
notes n = new notes();
n.Zap();
claim_batch cb = new claim_batch();
cb.Zap();
batch_claim_list bcl = new batch_claim_list();
bcl.Zap();
}
else
{
if (!changesOnly)
{
workingClaim.MarkAllImportsUpdated(false);
}
}
// Apply incremental updates to progress bar
int currentRow = 0;
totalRows = importData.Rows.Count + importDataSecondaries.Rows.Count + importDataPredeterms.Rows.Count + importDataSecondaryPredeterms.Rows.Count;
decimal exactIncrementAmount;
if (totalRows > 0)
{
exactIncrementAmount = 500m / totalRows;
}
else
{
exactIncrementAmount = 500m;
}
decimal incrementCounter = 0;
int increment;
if (exactIncrementAmount < 1)
{
increment = 1;
}
else
{
increment = Convert.ToInt32(Math.Truncate(exactIncrementAmount));
}
string lastClaimID = "";
claim aClaim = new claim();
company aCompany = new company();
company_contact_info anInfo = new company_contact_info();
procedure aProcedure = new procedure();
for (int p = 0; p < 4; p++)
{
claim.ClaimTypes ct;
DataTable thisImport;
switch (p)
{
case 0:
thisImport = importData;
ct = claim.ClaimTypes.Primary;
//UpdateLabels(0);
break;
case 1:
thisImport = importDataSecondaries;
ct = claim.ClaimTypes.Secondary;
//UpdateLabels(1);
break;
case 2:
thisImport = importDataPredeterms;
ct = claim.ClaimTypes.Predeterm;
//UpdateLabels(2);
break;
default:
thisImport = importDataSecondaryPredeterms;
//UpdateLabels(3);
ct = claim.ClaimTypes.SecondaryPredeterm;
break;
}
// Have data at this point, need to tie them to the internal mapping schema data
foreach (DataRow anImportRow in thisImport.Rows)
{
string newID = anImportRow[dms.claim_id_column].ToString();
string newDB = anImportRow[dms.claim_db_column].ToString();
bool isOnlyProcedureData;
if (newID == lastClaimID)
{
// We're only dealing with the import of "some" data
isOnlyProcedureData = true;
}
else
{
if (ct == claim.ClaimTypes.Primary)
{
primaryClaimCount++;
}
else if (ct == claim.ClaimTypes.Secondary)
{
secondaryClaimCount++;
}
else if (ct == claim.ClaimTypes.Predeterm)
{
predetermClaimCount++;
}
else
{
secondaryPredetermClaimCount++;
}
//UpdateTypeCount();
aClaim = FindClaim(anImportRow, ct);
aCompany = FindCompany(anImportRow[dms.company_namecolumn].ToString());
anInfo = FindContactInfo(anImportRow["Ins_Co_Street1"].ToString(), aCompany.id, anImportRow["Ins_Co_Phone"].ToString());
lastClaimID = newID;
aClaim.ClearClaimProcedures();
isOnlyProcedureData = false;
// Check for "X" in provider field
try
{
if (aClaim.doctor_provider_id.StartsWith("X"))
{
AddStatus(string.Format("The claim for patient {0} on {1} uses an X provider ({2})", aClaim.PatientName, aClaim.DatesOfServiceString(), aClaim.doctor_provider_id), true, true);
}
}
catch (Exception err)
{
CreateLogFile(err.ToString());
Updateimporterror(true);
DeleteDirectoryFromTemp();
//LoggingHelper.Log(err, false);
}
}
aProcedure = FindProcedure(anImportRow["PROC_LOGID"].ToString());
if (CommonFunctions.DBNullToString(anImportRow["DATERECEIVED"]) == "")
{
aClaim.open = 1;
}
else if (((DateTime)anImportRow["DATERECEIVED"]).Year == 1753)
{
aClaim.open = 1;
}
else
{
aClaim.open = 0;
UpdateStatusHistory(aClaim);
}
foreach (data_mapping_schema_data aMappedData in allMappedSchemaData)
{
// We do a check for is only procedure data to speed up processing
// It makes the code a little messier.
if (isOnlyProcedureData)
{
// If we're only importing the procedure data, none of the other information is important
if ((aMappedData.LinkedField.table_name == "claims") ||
(aMappedData.LinkedField.table_name == "companies") ||
(aMappedData.LinkedField.table_name == "company_contact_info"))
{
// Ignore
}
else if (aMappedData.LinkedField.table_name == "procedures")
{
if (aMappedData.LinkedField.field_name == "surf_string")
{
aProcedure[aMappedData.LinkedField.field_name] = CommonFunctions.RemoveNonPrintableCharacters(anImportRow[aMappedData.mapped_to_text].ToString());
}
else if (aMappedData.LinkedField.field_name == "claim_id")
{
aProcedure["claim_id"] = lastClaimID;
}
else
{
aProcedure[aMappedData.LinkedField.field_name] = anImportRow[aMappedData.mapped_to_text];
}
}
else
{
//LoggingHelper.Log("Uninitialized table name in frmImportData.Import", LogSeverity.Critical,
// new Exception("Uninitialized table name in import procedure."), true);
}
}
else
{
// This is a new claim - we need to get the data for every field
if (aMappedData.LinkedField.table_name == "claims")
{
aClaim[aMappedData.LinkedField.field_name] = anImportRow[aMappedData.mapped_to_text];
}
else if (aMappedData.LinkedField.table_name == "companies")
{
if (aMappedData.mapped_to_text != dms.company_namecolumn)
{
aCompany[aMappedData.LinkedField.field_name] = anImportRow[aMappedData.mapped_to_text];
}
}
else if (aMappedData.LinkedField.table_name == "company_contact_info")
{
anInfo[aMappedData.LinkedField.field_name] = anImportRow[aMappedData.mapped_to_text];
}
else if (aMappedData.LinkedField.table_name == "procedures")
{
if (aMappedData.LinkedField.field_name == "surf_string")
{
aProcedure[aMappedData.LinkedField.field_name] = CommonFunctions.RemoveNonPrintableCharacters(anImportRow[aMappedData.mapped_to_text].ToString());
}
else
{
aProcedure[aMappedData.LinkedField.field_name] = anImportRow[aMappedData.mapped_to_text];
}
}
else
{
//LoggingHelper.Log("Uninitialized table name in frmImport.Import", LogSeverity.Critical);
//throw new Exception("Uninitialized table name in import procedure.");
}
}
}
aCompany.Save();
anInfo.company_id = aCompany.id;
if (CommonFunctions.DBNullToZero(anInfo["order_id"]) == 0)
{
anInfo.order_id = anInfo.GetNextOrderID();
}
anInfo.Save();
aClaim.company_id = aCompany.id;
aClaim.company_address_id = anInfo.order_id;
aClaim["import_update_flag"] = true;
aClaim.Save();
if (p == 0 || p == 2 || p == 3) // Only update the id if this is the primary claim or a predeterm
{
aProcedure.claim_id = aClaim.id;
}
aProcedure.Save();
currentRow++;
if (Math.Truncate(incrementCounter + exactIncrementAmount) != Math.Truncate(incrementCounter))
{
//UpdateProgressBar(increment, string.Format("{0} / {1} procedures completed...", currentRow, totalRows), false);
}
incrementCounter += exactIncrementAmount;
}
}
if (changesOnly)
{
// Grab all the deleted claims and mark them as closed here
// Add a note that they have been deleted, I guess
string deletedClaimsSQL = "SELECT CLAIMID, CLAIMDB " +
"FROM AUDIT_DDB_CLAIM " +
"WHERE N_CLAIMID is null " +
"AND CLAIMID is not null AND CLAIMDB is not null " +
"AND date_changed >= '" + lastWrite.ToString("G") + "'";
DataTable deletedClaims = new DataTable();
OleDbCommand cmd = new OleDbCommand(deletedClaimsSQL, oConnect);
cmd.CommandTimeout = 90;
oAdapter = new OleDbDataAdapter(cmd);
oAdapter.Fill(deletedClaims);
//UpdateProgressBar(5, "Updating Local Status for Deleted Claims...");
foreach (DataRow aDeletedClaim in deletedClaims.Rows)
{
// Close the claims
DataTable matches = aClaim.Search("SELECT * FROM claims WHERE claimidnum = '" + aDeletedClaim["claimid"] +
"' and claimdb = '" + aDeletedClaim["claimdb"] + "'");
if (matches.Rows.Count > 0)
{
// This should honestly not load every claim
aClaim = new claim();
aClaim.Load(matches.Rows[0]);
aClaim.open = 0;
aClaim.Save();
UpdateStatusHistory(aClaim);
closedClaimCount++;
}
}
}
else
{
closedClaimCount = workingClaim.CloseClaimsWithoutUpdate();
}
//UpdateLabels(4);
workingClaim.FixRevisitDateAfterImport();
system_options.SetLastImportDate(DateTime.Now);
ShowLastImportDate();
AddStatus("The import completed successfully! " + totalRows + " rows were imported.");
AddReportMessage(string.Format("The import completed successfully!\nPrimary: {0}\nSecondary: {1}\n" +
"Predeterm: {2}\nSecondary Predeterm: {3}\nTotal Open Claims: {4}", primaryClaimCount, secondaryClaimCount, predetermClaimCount, secondaryPredetermClaimCount,
primaryClaimCount + secondaryClaimCount + predetermClaimCount + secondaryPredetermClaimCount));
try
{
string importFileName = Application.StartupPath + "\\Imports\\" + DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss") + " import.rtf";
//Directory.CreateDirectory(Path.GetDirectoryName(importFileName));
//rtxtReport.SaveFile(importFileName);
saveFileFromTemp();
DeleteDirectoryFromTemp();
CreateLogFile("Import Successfully.");
Updateimporterror(false);
}
catch (Exception ex) {
CreateLogFile(ex.ToString());
Updateimporterror(true);
DeleteDirectoryFromTemp();
//LoggingHelper.Log("Error creating import report file.", LogSeverity.Error, ex, false);
}
}
private T MAKECALL <T>(CALLTYPE type, UInt32 thisPtr, UInt32 fcallArg, UInt32 funcPtr, CallValue[] args) where T : CallValue, new()
{
if (funcPtr == 0)
{
throw new Exception("Funcptr not found");
}
T returnValue = new T();
List <byte> list = new List <byte>();
list.Add(0x60);//pushad
int argsCount = 0;
//Argumente pushen
if (args != null)
{
for (int i = args.Length - 1; i >= 0; i--)
{
for (int i2 = args[i].getCallParam().Count - 1; i2 >= 0; i2--)
{
argsCount++;
list.Add(0x68);
list.AddRange(args[i].getCallParam()[i2]);
}
}
}
//This-Pointer in ecx schreiben
if (type == CALLTYPE.THISCALL || type == CALLTYPE.FASTCALL)
{
list.Add(0xB9);
list.AddRange(BitConverter.GetBytes(thisPtr));
}
//Fastcall pointer in edx schreiben
if (type == CALLTYPE.FASTCALL)
{
list.Add(0xBA);
list.AddRange(BitConverter.GetBytes(fcallArg));
}
uint length = (uint)(list.Count + 1 + 4 + 1 + 1);
if (returnValue.ValueLength() != 0)
{
length += 1 + returnValue.ValueLength();
}
if (type == CALLTYPE.CDECLCALL)
{
length += 3;
}
IntPtr baseadress = Alloc(length);
IntPtr returnAddress = IntPtr.Zero;
if (returnValue.ValueLength() != 0)
{
returnAddress = Alloc(returnValue.ValueLength());
}
//call
list.Add(0xE8);
list.AddRange(BitConverter.GetBytes((uint)(funcPtr - (baseadress.ToInt32() + list.Count) - 4))); // - Aktuelle Addresse - 4
//Return schreiben
if (returnValue.ValueLength() != 0)
{
list.Add(0xA3);
list.AddRange(BitConverter.GetBytes((uint)returnAddress.ToInt32()));
}
if (type == CALLTYPE.CDECLCALL)
{
list.AddRange(new byte[] { 0x83, 0xC4 });
list.Add((byte)(argsCount * 4));
}
list.Add(0x61); //popad
list.Add(0xC3); //RTN
//Write the new function
Write(list.ToArray(), baseadress.ToInt32());
//Call the new function
if (process_thisprocess)
{
call mc = (call)Marshal.GetDelegateForFunctionPointer(baseadress, typeof(call));
mc();
}
else
{
uint threadID;
IntPtr hThread = Kernel.Process.CreateRemoteThread(Handle, IntPtr.Zero, 0, baseadress, IntPtr.Zero, 0, out threadID);
WaitForThreadToExit(hThread);
CloseHandle(hThread);
}
//Bisschen aufräumen
Free(baseadress, length);
if (returnValue.ValueLength() != 0)
{
returnValue.Initialize(this, ReadInt(returnAddress.ToInt32()));//Adresse in der die return Value gespeichert wurde
Free(returnAddress, returnValue.ValueLength());
return(returnValue);
}
else
{
return(null);
}
}
private bool IsCall(InvocationExpressionSyntax invocation, SemanticModel semanticModel) => invocation.Expression is MemberAccessExpressionSyntax call && IsCall(call, semanticModel);
private static T MAKECALL <T>(CALLTYPE type, int thisPtr, int fcallArg, int funcPtr, params CallValue[] args) where T : CallValue, new()
{
if (funcPtr == 0)
{
throw new Exception("Process.MAKECALL: Method-pointer not found");
}
List <byte> list = new List <byte>();
list.Add(0x60);//pushad
int argsCount = 0;
//Argumente pushen
if (args != null)
{
for (int i = args.Length - 1; i >= 0; i--)
{
CallValue arg = args[i];
if (arg != null)
{
List <byte[]> callParams = args[i].GetCallParams();
for (int i2 = callParams.Count - 1; i2 >= 0; i2--)
{
argsCount++;
list.Add(0x68);
list.AddRange(callParams[i2]);
}
}
}
}
//This-Pointer in ecx schreiben
if (type == CALLTYPE.THISCALL || type == CALLTYPE.FASTCALL)
{
list.Add(0xB9);
list.AddRange(BitConverter.GetBytes(thisPtr));
}
//Fastcall pointer in edx schreiben
if (type == CALLTYPE.FASTCALL)
{
list.Add(0xBA);
list.AddRange(BitConverter.GetBytes(fcallArg));
}
T returnValue = new T();
uint length = (uint)(list.Count + 1 + 4 + 1 + 1);
if (returnValue.ValueLength() != 0)
{
length += 1 + returnValue.ValueLength();
}
if (type == CALLTYPE.CDECLCALL)
{
length += 3;
}
IntPtr baseadress = Alloc(length);
IntPtr returnAddress = IntPtr.Zero;
if (returnValue.ValueLength() != 0)
{
returnAddress = Alloc(returnValue.ValueLength());
}
//call
list.Add(0xE8);
list.AddRange(BitConverter.GetBytes(funcPtr - (baseadress.ToInt32() + list.Count) - 4)); // - Aktuelle Addresse - 4
//Return schreiben
if (returnValue.ValueLength() != 0)
{
list.Add(0xA3);
list.AddRange(BitConverter.GetBytes((uint)returnAddress.ToInt32()));
}
if (type == CALLTYPE.CDECLCALL)
{
list.AddRange(new byte[] { 0x83, 0xC4 });
list.Add((byte)(argsCount * 4));
}
list.Add(0x61); //popad
list.Add(0xC3); //RTN
//Write the new function
Write(baseadress.ToInt32(), list.ToArray());
//Call the new function
call mc = (call)Marshal.GetDelegateForFunctionPointer(baseadress, typeof(call));
mc();
//Bisschen aufräumen
Free(baseadress, length);
if (returnValue.ValueLength() != 0)
{
returnValue.Initialize(returnAddress.ToInt32());//Adresse in der die return Value gespeichert wurde
Free(returnAddress, returnValue.ValueLength());
return(returnValue);
}
else
{
return(null);
}
}
/// <summary>
/// Creates a new row in the database
/// </summary>
/// <returns>Insert ID of the new row</returns>
public override int New()
{
base.New();
CurrentRow = new call();
received = DateTime.Now;
CurrentConnection.calls.InsertOnSubmit(CurrentRow);
CurrentConnection.SubmitChanges();
return CurrentRow.id;
}
/// <summary>
/// Load the model with data (row from the DB)
/// </summary>
/// <param name="CallId"></param>
/// <returns></returns>
public override bool Load(int CallId)
{
base.Load(CallId);
CurrentConnection = new DatabaseDataContext();
var q = from x in CurrentConnection.calls where x.id.Equals(CallId) && x.deleted.Equals(0) select x;
CurrentRow = q.FirstOrDefault();
Caller = new Model.Person(caller_id > 0 ? (int)caller_id : Model.Person.ANONYMOUS);
return true;
}