public void ApplySignatureToProcedure(Address addr, ProcedureSignature sig, Procedure proc)
{
proc.Signature = sig;
int i = 0;
var stmts = proc.EntryBlock.Succ[0].Statements;
var linAddr = addr.ToLinear();
foreach (var param in sig.Parameters)
{
var starg = param.Storage as StackArgumentStorage;
if (starg != null)
{
proc.Frame.EnsureStackArgument(
starg.StackOffset + sig.ReturnAddressOnStack,
param.DataType,
param.Name);
}
else
{
var paramId = proc.Frame.EnsureIdentifier(param.Storage);
paramId.DataType = param.DataType;
// Need to take an extra step with parameters being passed
// in a register. It's perfectly possible for a user to
// create a variable which they want to call 'r2' but which
// the calling convention of the machine wants to call 'r1'.
// To avoid this, we create a temporary identifier for
// the formal parameter, and inject an copy statement in the
// entry block that moves the parameter value into the
// register.
stmts.Insert(i, linAddr, NewMethod(param, paramId));
++i;
}
}
}
public void Test_Constructor_Procedure()
{
Procedure procedure = new Procedure();
InterpretationStep procedureStep = new InterpretationStep(procedure);
Assert.IsNull(procedureStep.ReportPart);
}
public IEnumerable<Parameter> GetParameters(Procedure storedProcedure)
{
var list = new List<Parameter>();
using (var connection = _connectionProvider.CreateConnection())
{
connection.Open();
var command = connection.CreateCommand();
command.CommandType = CommandType.Text;
command.CommandText =
string.Format("SELECT * FROM information_schema.parameters WHERE SPECIFIC_NAME = '{0}';",
storedProcedure.Name);
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
list.Add(new Parameter
(
reader["PARAMETER_NAME"].ToString(),
SqlTypeResolver.GetClrType(reader["DATA_TYPE"].ToString()),
GetParameterDirection(reader["PARAMETER_MODE"].ToString()),
MysqlColumnInfo.GetDbType(reader["DATA_TYPE"].ToString()),
Convert.IsDBNull(reader["CHARACTER_MAXIMUM_LENGTH"]) ? -1 : Convert.ToInt32(reader["CHARACTER_MAXIMUM_LENGTH"])
));
}
}
connection.Close();
return list;
}
}
public void Test_Name()
{
Procedure procedure = new Procedure();
InterpretationStep procedureStep = new InterpretationStep(procedure);
Assert.AreEqual("Interpretation", procedureStep.Name);
}
protected void TryAutoTerminateProcedureSteps(Procedure procedure, DateTime? time, IWorkflow workflow)
{
foreach (var mps in procedure.ModalityProcedureSteps)
{
// if the MPS is not terminated and has some MPPS
if(!mps.IsTerminated && !mps.PerformedSteps.IsEmpty)
{
var allMppsDiscontinued = CollectionUtils.TrueForAll(mps.PerformedSteps,
(PerformedProcedureStep pps) => pps.State == PerformedStepStatus.DC);
var allMppsTerminated = CollectionUtils.TrueForAll(mps.PerformedSteps,
(PerformedProcedureStep pps) => pps.IsTerminated);
if (allMppsDiscontinued)
{
// discontinue MPS, since all MPPS are discontinued
mps.Discontinue(time);
}
else if (allMppsTerminated)
{
// all MPPS are terminated, and at least one MPPS must be completed, so complete MPS
mps.Complete(time);
}
}
}
}
public SegmentedAccessClassifier(Procedure proc, SsaIdentifierCollection ssaIds)
{
this.proc = proc;
this.ssaIds = ssaIds;
assocs = new Dictionary<Identifier,Identifier>();
consts = new Dictionary<Identifier, Constant>();
}
public void DisplayProcedure(Procedure proc)
{
if (proc == null)
return;
ShowWindow("codeViewerWindow", "Code Viewer", pane);
pane.DisplayProcedure(proc);
}
public void Test_CanApprove()
{
Procedure procedure = new Procedure();
Protocol protocol = new Protocol(procedure);
ProtocolAssignmentStep procedureStep = new ProtocolAssignmentStep(protocol);
Assert.AreEqual(ProtocolStatus.PN, procedureStep.Protocol.Status);
Assert.IsFalse(procedureStep.CanApprove);
protocol.SubmitForApproval();
Assert.AreEqual(ActivityStatus.SC, procedureStep.State);
Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status);
Assert.IsTrue(procedureStep.CanApprove);
procedureStep.Start(new Staff());
Assert.AreEqual(ActivityStatus.IP, procedureStep.State);
Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status);
Assert.IsTrue(procedureStep.CanApprove);
procedureStep.Suspend();
Assert.AreEqual(ActivityStatus.SU, procedureStep.State);
Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status);
Assert.IsFalse(procedureStep.CanApprove);
procedureStep.Complete();
Assert.AreEqual(ActivityStatus.CM, procedureStep.State);
Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status);
Assert.IsFalse(procedureStep.CanApprove);
// TODO : test all other Protocol state conditions
}
public void CollectTypes()
{
desc.MeetDataType(program.Globals, factory.CreatePointer(
factory.CreateStructureType(),
program.Platform.PointerType.Size));
CollectSegmentTypes();
foreach (Procedure p in program.Procedures.Values)
{
proc = p;
CollectProcedureSignature(p);
foreach (Statement stm in p.Statements)
{
if (eventListener.IsCanceled())
return;
try
{
stm.Instruction.Accept(this);
}
catch (Exception ex)
{
eventListener.Error(
eventListener.CreateStatementNavigator(program, stm),
ex,
"An error occurred while processing the statement {0}.",
stm);
}
}
}
}
private void Given_Procedure(uint address)
{
var m = new ProcedureBuilder("fnTest");
m.Return();
this.proc = m.Procedure;
this.program.Procedures[Address.Ptr32(address)] = this.proc;
}
public Cmd_EditSignature(IServiceProvider services, Program program, Procedure procedure, Address addr)
: base(services)
{
this.program = program;
this.procedure = procedure;
this.address = addr;
}
public void Transform(Procedure proc)
{
foreach (var stm in proc.Statements)
{
stm.Instruction.Accept(this);
}
}
public void Cmasp_Do()
{
var addr = Address.SegPtr(0x0C20, 0);
var proc = new Procedure("foo", null);
var progaddr = new ProgramAddress(program, addr);
var dc = mr.Stub<IDecompiler>();
var dcSvc = mr.Stub<IDecompilerService>();
var brSvc = mr.Stub<IProjectBrowserService>();
dcSvc.Decompiler = dc;
sc.AddService<IDecompilerService>(dcSvc);
sc.AddService<IProjectBrowserService>(brSvc);
sc.AddService<IDecompilerShellUiService>(new FakeShellUiService());
dc.Expect(d => d.ScanProcedure(progaddr)).IgnoreArguments().Return(proc);
brSvc.Expect(b => b.Reload());
mr.ReplayAll();
var locations = new[] { new ProgramAddress(program, addr) };
var cmd = new Cmd_MarkProcedures(sc, locations);
cmd.DoIt();
mr.VerifyAll();
Assert.AreEqual(1, program.User.Procedures.Count);
var uproc = program.User.Procedures.Values[0];
Assert.AreEqual("0C20:0000", uproc.Address);
}
public IEnumerable<Parameter> GetParameters(Procedure storedProcedure)
{
var parameters = _sqlReflection.ProcedureArguments
.Where(p => p.Item1.InvariantEquals(storedProcedure.Name))
.Select(p => new Parameter(p.Item2, p.Item3, p.Item4));
return parameters;
}
private string GuessName(Procedure_v1 userProc, Procedure proc = null)
{
if (userProc != null)
{
if (!string.IsNullOrEmpty(userProc.Name))
return userProc.Name;
if (!string.IsNullOrEmpty(userProc.CSignature))
{
int i = userProc.CSignature.IndexOf('(');
if (i > 0)
{
var name = userProc.CSignature.Remove(i);
do
{
--i;
} while (i > 0 && (char.IsLetterOrDigit(name[i]) || name[i] == '_'));
return name.Substring(i + 1);
}
}
}
if (proc != null)
{
return proc.Name;
}
else
{
return null;
}
}
public LiveCopyInserter(Procedure proc, SsaIdentifierCollection ssaIds)
{
this.proc = proc;
this.ssaIds = ssaIds;
this.sla = new SsaLivenessAnalysis(proc, ssaIds);
this.doms = proc.CreateBlockDominatorGraph();
}
public Prior(Report r, Procedure rp, ProcedureType pt, Order o)
{
this.Report = r;
this.Procedure = rp;
this.ProcedureType = pt;
this.Order = o;
}
public static Schema.KRPC.Services GetServices()
{
var services = new Schema.KRPC.Services ();
foreach (var serviceSignature in Services.Instance.Signatures.Values) {
var service = new Schema.KRPC.Service ();
service.Name = serviceSignature.Name;
foreach (var procedureSignature in serviceSignature.Procedures.Values) {
var procedure = new Procedure ();
procedure.Name = procedureSignature.Name;
if (procedureSignature.HasReturnType)
{
procedure.HasReturnType = true;
procedure.ReturnType = TypeUtils.GetTypeName (procedureSignature.ReturnType);
}
foreach (var parameterSignature in procedureSignature.Parameters) {
var parameter = new Parameter ();
parameter.Name = parameterSignature.Name;
parameter.Type = TypeUtils.GetTypeName (parameterSignature.Type);
if (parameterSignature.HasDefaultArgument)
{
parameter.HasDefaultArgument = true;
parameter.DefaultArgument = parameterSignature.DefaultArgument;
}
procedure.Parameters.Add (parameter);
}
foreach (var attribute in procedureSignature.Attributes) {
procedure.Attributes.Add (attribute);
}
if (procedureSignature.Documentation != "")
procedure.Documentation = procedureSignature.Documentation;
service.Procedures.Add (procedure);
}
foreach (var clsSignature in serviceSignature.Classes.Values) {
var cls = new Class ();
cls.Name = clsSignature.Name;
if (clsSignature.Documentation != "")
cls.Documentation = clsSignature.Documentation;
service.Classes.Add (cls);
}
foreach (var enmSignature in serviceSignature.Enumerations.Values) {
var enm = new Enumeration ();
enm.Name = enmSignature.Name;
if (enmSignature.Documentation != "")
enm.Documentation = enmSignature.Documentation;
foreach (var enmValueSignature in enmSignature.Values) {
var enmValue = new EnumerationValue ();
enmValue.Name = enmValueSignature.Name;
enmValue.Value = enmValueSignature.Value;
if (enmValueSignature.Documentation != "")
enmValue.Documentation = enmValueSignature.Documentation;
enm.Values.Add (enmValue);
}
service.Enumerations.Add (enm);
}
if (serviceSignature.Documentation != "")
service.Documentation = serviceSignature.Documentation;
services.Services_.Add (service);
}
return services;
}
public void Test_IsPreStep()
{
Procedure procedure = new Procedure();
DocumentationProcedureStep procedureStep = new DocumentationProcedureStep(procedure);
Assert.IsFalse(procedureStep.IsPreStep);
}
public void Test_Constructor()
{
Procedure procedure = new Procedure();
DocumentationProcedureStep procedureStep = new DocumentationProcedureStep(procedure);
Assert.AreEqual(procedure, procedureStep.Procedure);
}
// call
public static CodeAddress call1 (Procedure p, int argc)
{
#if HAS_PERFORMANCE_COUNTERS
if (Call.schemeCallCounter != null) Call.schemeCallCounter.Increment();
#endif
throw new SchemeCallException (p, argc);
}
public void Test_Name()
{
Procedure procedure = new Procedure();
DocumentationProcedureStep procedureStep = new DocumentationProcedureStep(procedure);
Assert.AreEqual("Documentation", procedureStep.Name);
}
protected void DumpSsaInfo(Procedure proc, SsaState ssa, TextWriter writer)
{
writer.WriteLine("// {0} ////////////////////////////////", proc.Name);
DumpSsaTypes(ssa, writer);
proc.Write(false, writer);
writer.WriteLine();
}
///<summary>Inserts one Procedure into the database. Returns the new priKey.</summary>
internal static long Insert(Procedure procedure)
{
if(DataConnection.DBtype==DatabaseType.Oracle) {
procedure.ProcNum=DbHelper.GetNextOracleKey("procedurelog","ProcNum");
int loopcount=0;
while(loopcount<100){
try {
return Insert(procedure,true);
}
catch(Oracle.DataAccess.Client.OracleException ex){
if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){
procedure.ProcNum++;
loopcount++;
}
else{
throw ex;
}
}
}
throw new ApplicationException("Insert failed. Could not generate primary key.");
}
else {
return Insert(procedure,false);
}
}
public void Setup()
{
mr = new MockRepository();
program = new Program();
proc = new Procedure("testProc", new Frame(PrimitiveType.Word32));
block = proc.AddBlock("l00100000");
trace = new RtlTrace(0x00100000);
r0 = new Identifier("r0", PrimitiveType.Word32, new RegisterStorage("r0", 0, 0, PrimitiveType.Word32));
r1 = new Identifier("r1", PrimitiveType.Word32, new RegisterStorage("r1", 1, 0, PrimitiveType.Word32));
r2 = new Identifier("r2", PrimitiveType.Word32, new RegisterStorage("r2", 2, 0, PrimitiveType.Word32));
sp = new Identifier("sp", PrimitiveType.Word32, new RegisterStorage("sp", 15, 0, PrimitiveType.Word32));
grf = proc.Frame.EnsureFlagGroup(Registers.eflags, 3, "SCZ", PrimitiveType.Byte);
var sc = new ServiceContainer();
var listener = mr.Stub<DecompilerEventListener>();
scanner = mr.StrictMock<IScanner>();
arch = mr.Stub<IProcessorArchitecture>();
program.Architecture = arch;
program.SegmentMap = new SegmentMap(
Address.Ptr32(0x00100000),
new ImageSegment(
".text",
new MemoryArea(Address.Ptr32(0x00100000), new byte[0x20000]),
AccessMode.ReadExecute));
arch.Replay();
program.Platform = new DefaultPlatform(null, arch);
arch.BackToRecord();
arch.Stub(s => s.StackRegister).Return((RegisterStorage)sp.Storage);
arch.Stub(s => s.PointerType).Return(PrimitiveType.Pointer32);
scanner.Stub(s => s.Services).Return(sc);
sc.AddService<DecompilerEventListener>(listener);
}
public virtual IEnumerable<Parameter> GetParameters(Procedure storedProcedure)
{
var parameters = Reflector.ProcedureArguments
.Where(p => p.Item1.InvariantEquals(storedProcedure.Name) && p.Item5.InvariantEquals(storedProcedure.Schema))
.Select(p => new Parameter(p.Item2, p.Item3, p.Item4));
return parameters;
}
public bool BuildSignature(Address addr, Procedure proc)
{
Procedure_v1 userProc;
if (program.User.Procedures.TryGetValue(addr, out userProc))
{
var sProc = DeserializeSignature(userProc, proc);
if (sProc != null)
{
var ser = program.CreateProcedureSerializer();
var sig = ser.Deserialize(sProc.Signature, proc.Frame);
if (sig != null)
{
proc.Name = sProc.Name;
ApplySignatureToProcedure(addr, sig, proc);
return true;
}
}
}
if (proc.Signature.ParametersValid)
{
ApplySignatureToProcedure(addr, proc.Signature, proc);
return true;
}
return false;
}
Image GetImageFromGoogleCharts(Dimensions dimensions)
{
var chl = "&chl=" + Uri.EscapeDataString(GetValue<string>("text"));
var chs = string.Format("&chs={0}x{1}", dimensions.Width,
dimensions.Height);
var choe = "&choe=" + GetEncodingString();
var chld = string.Format("&chld={0}|{1}", GetValue<string>("error_correction"),
GetValue<int>("margin"));
var url = "http://chart.apis.google.com/chart?cht=qr"
+ chl + chs + choe + chld;
var procedure = new Procedure("file-uri-load");
try
{
var returnArgs = procedure.Run(url, url);
return returnArgs[0] as Image;
}
catch (GimpSharpException e)
{
new Message(e.Message);
return null;
}
}
protected void Page_Init(object sender, EventArgs e)
{
ctx = new AriClinicContext("AriClinicContext");
// security control, it must be a user logged
if (Session["User"] == null)
Response.Redirect("Default.aspx");
else
{
user = CntAriCli.GetUser((Session["User"] as User).UserId, ctx);
Process proc = (from p in ctx.Processes
where p.Code == "procedure"
select p).FirstOrDefault<Process>();
per = CntAriCli.GetPermission(user.UserGroup, proc, ctx);
btnAccept.Visible = per.Modify;
}
//
if (Request.QueryString["ProcedureId"] != null)
{
procedureId = Int32.Parse(Request.QueryString["ProcedureId"]);
proc = CntAriCli.GetProcedure(procedureId, ctx);
LoadData(proc);
}
// Allways read parameter
parameter = CntAriCli.GetParameter(ctx);
}
public void Add(Procedure proc)
{
++procCount;
Program.Procedures[Address.Ptr32(procCount * 0x1000u)] = proc;
Program.CallGraph.AddProcedure(proc);
nameToProcedure[proc.Name] = proc;
}
public ControlFlowGraphCleaner(Procedure proc)
{
this.proc = proc;
}
///<summary>Returns null if there is no DFT defined for the enabled HL7Def.</summary>
public static MessageHL7 GenerateDFT(List <Procedure> procList, EventTypeHL7 eventType, Patient pat, Patient guar, long aptNum, string pdfDescription, string pdfDataString) //add event (A04 etc) parameters later if needed
//In \\SERVERFILES\storage\OPEN DENTAL\Programmers Documents\Standards (X12, ADA, etc)\HL7\Version2.6\V26_CH02_Control_M4_JAN2007.doc
//On page 28, there is a Message Construction Pseudocode as well as a flowchart which might help.
{
Provider prov = Providers.GetProv(Patients.GetProvNum(pat));
Appointment apt = Appointments.GetOneApt(aptNum);
MessageHL7 messageHL7 = new MessageHL7(MessageTypeHL7.DFT);
HL7Def hl7Def = HL7Defs.GetOneDeepEnabled();
if (hl7Def == null)
{
return(null);
}
//find a DFT message in the def
HL7DefMessage hl7DefMessage = null;
for (int i = 0; i < hl7Def.hl7DefMessages.Count; i++)
{
if (hl7Def.hl7DefMessages[i].MessageType == MessageTypeHL7.DFT)
{
hl7DefMessage = hl7Def.hl7DefMessages[i];
//continue;
break;
}
}
if (hl7DefMessage == null) //DFT message type is not defined so do nothing and return
{
return(null);
}
for (int s = 0; s < hl7DefMessage.hl7DefSegments.Count; s++)
{
int countRepeat = 1;
if (hl7DefMessage.hl7DefSegments[s].SegmentName == SegmentNameHL7.FT1)
{
countRepeat = procList.Count;
}
//for example, countRepeat can be zero in the case where we are only sending a PDF of the TP to eCW, and no procs.
for (int repeat = 0; repeat < countRepeat; repeat++) //FT1 is optional and can repeat so add as many FT1's as procs in procList
//if(hl7DefMessage.hl7DefSegments[s].SegmentName==SegmentNameHL7.FT1) {
{
if (hl7DefMessage.hl7DefSegments[s].SegmentName == SegmentNameHL7.FT1 && procList.Count > repeat)
{
prov = Providers.GetProv(procList[repeat].ProvNum);
}
SegmentHL7 seg = new SegmentHL7(hl7DefMessage.hl7DefSegments[s].SegmentName);
seg.SetField(0, hl7DefMessage.hl7DefSegments[s].SegmentName.ToString());
for (int f = 0; f < hl7DefMessage.hl7DefSegments[s].hl7DefFields.Count; f++)
{
string fieldName = hl7DefMessage.hl7DefSegments[s].hl7DefFields[f].FieldName;
if (fieldName == "") //If fixed text instead of field name just add text to segment
{
seg.SetField(hl7DefMessage.hl7DefSegments[s].hl7DefFields[f].OrdinalPos, hl7DefMessage.hl7DefSegments[s].hl7DefFields[f].FixedText);
}
else
{
//seg.SetField(hl7DefMessage.hl7DefSegments[s].hl7DefFields[f].OrdinalPos,
//FieldConstructor.GenerateDFT(hl7Def,fieldName,pat,prov,procList[repeat],guar,apt,repeat+1,eventType,pdfDescription,pdfDataString));
Procedure proc = null;
if (procList.Count > repeat) //procList could be an empty list
{
proc = procList[repeat];
}
seg.SetField(hl7DefMessage.hl7DefSegments[s].hl7DefFields[f].OrdinalPos,
FieldConstructor.GenerateDFT(hl7Def, fieldName, pat, prov, proc, guar, apt, repeat + 1, eventType, pdfDescription, pdfDataString));
}
}
messageHL7.Segments.Add(seg);
}
}
return(messageHL7);
}
public SsaState(Procedure proc)
{
this.Procedure = proc;
this.Identifiers = new SsaIdentifierCollection();
}
public CompoundConditionCoalescer(Procedure proc)
{
this.proc = proc;
this.m = new ExpressionEmitter();
}
public TailReturnRemover(Procedure proc)
{
this.proc = proc;
}
public ProcedureNavigator(Program program, Procedure proc, IServiceProvider sp)
{
this.program = program;
this.Procedure = proc;
this.sp = sp;
}
public NeoValue Call(NeoValue[] arguments)
{
var scope = new Scope(ParentScope);
var level = scope.Level;
var pargs = new List <NeoValue>();
foreach (var arg in arguments)
{
if (arg is NeoSpreadValue va)
{
for (var i = 0; i < va.Array.Count; i++)
{
pargs.Add(va.Array[i]);
}
}
else
{
pargs.Add(arg);
}
}
var varargs = new NeoArray();
var extraArgs = pargs.Count - Procedure.Parameters.Length;
if (extraArgs > 0)
{
for (var i = 0; i < extraArgs; i++)
{
varargs.Insert(pargs[Procedure.Parameters.Length + i]);
}
}
for (var i = 0; i < Procedure.Parameters.Length; i++)
{
var name = Procedure.Parameters[i].Name;
scope.Declare(name, VariableFlags.NONE);
var value = i < pargs.Count ? pargs[i] : NeoNil.NIL;
if (Procedure.Parameters[i].Frozen)
{
value = value.Frozen();
}
scope.Set(name, value);
}
var code = Procedure.Instructions;
var ip = 4;
var stack = new Stack <NeoValue>();
var rootScopeLevel = scope.Level;
var openUps = new Dictionary <string, UpValue>();
var defers = new Stack <NeoProcedure>();
byte ReadByte() => code[ip++];
OpCode ReadOpCode() => (OpCode)ReadByte();
short ReadShort() => (short)(ReadByte() | (ReadByte() << 8));
int ReadInt() => ReadByte() | (ReadByte() << 8) | (ReadByte() << 16) | (ReadByte() << 24);
NeoValue ReadConstant() => Procedure.Constants[ReadInt()];
while (ip < code.Length)
{
var op = ReadOpCode();
try {
switch (op)
{
case OpCode.NOP:
break;
case OpCode.INC: {
stack.Push(stack.Pop().Inc());
}
break;
case OpCode.DEC: {
stack.Push(stack.Pop().Dec());
}
break;
case OpCode.ADD: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Add(b));
}
break;
case OpCode.SUB: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Sub(b));
}
break;
case OpCode.MUL: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Mul(b));
}
break;
case OpCode.DIV: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Div(b));
}
break;
case OpCode.POW: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Pow(b));
}
break;
case OpCode.MOD: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Mod(b));
}
break;
case OpCode.LSH: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Lsh(b));
}
break;
case OpCode.RSH: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Rsh(b));
}
break;
case OpCode.BIT_NOT: {
stack.Push(stack.Pop().BitNot());
}
break;
case OpCode.BIT_AND: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.BitAnd(b));
}
break;
case OpCode.BIT_OR: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.BitOr(b));
}
break;
case OpCode.BIT_XOR: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.BitXor(b));
}
break;
case OpCode.NOT: {
stack.Push(stack.Pop().Not());
}
break;
case OpCode.NEG: {
stack.Push(stack.Pop().Neg());
}
break;
case OpCode.CONCAT: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Concat(b));
}
break;
case OpCode.LENGTH: {
stack.Push(stack.Pop().Length());
}
break;
case OpCode.ARRAY_NEW: {
stack.Push(new NeoArray());
}
break;
case OpCode.ARRAY_ADD: {
var element = stack.Pop();
var array = stack.Pop().CheckArray();
array.Insert(element);
}
break;
case OpCode.OBJECT_NEW: {
stack.Push(new NeoObject());
}
break;
case OpCode.OBJECT_INDEX: {
var index = stack.Pop().CheckInt();
var obj = stack.Pop().CheckObject();
stack.Push(obj.Index(index.Value));
stack.Push(obj.Get(obj.Index(index.Value)));
}
break;
case OpCode.GET: {
var key = stack.Pop();
var obj = stack.Pop();
stack.Push(obj.Get(key));
}
break;
case OpCode.SET: {
var value = stack.Pop();
var key = stack.Pop();
var obj = stack.Pop();
obj.Set(key, value);
}
break;
case OpCode.SLICE: {
var end = stack.Pop();
var start = stack.Pop();
stack.Push(stack.Pop().Slice(start, end));
}
break;
case OpCode.EQ: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Eq(b));
}
break;
case OpCode.NE: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Ne(b));
}
break;
case OpCode.DEEP_EQ: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.DeepEq(b));
}
break;
case OpCode.DEEP_NE: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.DeepNe(b));
}
break;
case OpCode.LT: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Lt(b));
}
break;
case OpCode.GT: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Gt(b));
}
break;
case OpCode.LTE: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Lte(b));
}
break;
case OpCode.GTE: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(a.Gte(b));
}
break;
case OpCode.CMP: {
var b = stack.Pop();
var a = stack.Pop();
stack.Push(NeoInt.ValueOf(a.Compare(b)));
}
break;
case OpCode.JUMP: {
ip = ReadInt();
}
break;
case OpCode.JUMP_IF: {
var addr = ReadInt();
if (stack.Pop().CheckBool().Value)
{
ip = addr;
}
}
break;
case OpCode.CALL: {
var line = Procedure.FindLine(ip);
var nargs = ReadShort();
var args = new NeoValue[nargs];
for (var i = nargs - 1; i >= 0; i--)
{
args[i] = stack.Pop();
}
var callee = stack.Pop();
if (callee.IsProcedure)
{
var proc = callee.CheckProcedure();
VM.PushFrame(proc.ChunkName(), proc.Name(), line);
stack.Push(proc.Call(args));
VM.PopFrame();
}
else
{
VM.PushFrame("<unknown>", "<unknown>", line);
stack.Push(callee.Call(args));
VM.PopFrame();
}
}
break;
case OpCode.RETURN: {
foreach (var up in openUps.Values)
{
up.Close();
}
NeoValue rvalue = null;
if (ReadByte() == 1)
{
rvalue = stack.Pop();
}
else
{
if (stack.Count > 0)
{
throw new Exception("VM error: stack not empty");
}
rvalue = NeoNil.NIL;
}
while (defers.Count > 0)
{
defers.Pop().Call(new NeoValue[0]);
}
return(rvalue);
}
case OpCode.DEFER: {
defers.Push(stack.Pop().CheckProcedure());
}
break;
case OpCode.VARARGS: {
if (!Procedure.Varargs)
{
stack.Push(NeoNil.NIL);
}
else
{
stack.Push(varargs);
}
}
break;
case OpCode.PUSH_TRUE: {
stack.Push(NeoBool.TRUE);
}
break;
case OpCode.PUSH_FALSE: {
stack.Push(NeoBool.FALSE);
}
break;
case OpCode.PUSH_NIL: {
stack.Push(NeoNil.NIL);
}
break;
case OpCode.PUSH_CONSTANT: {
stack.Push(ReadConstant());
}
break;
case OpCode.DUP: {
var a = stack.Pop();
stack.Push(a);
stack.Push(a);
}
break;
case OpCode.SWAP: {
var a = stack.Pop();
var b = stack.Pop();
stack.Push(a);
stack.Push(b);
}
break;
case OpCode.POP: {
stack.Pop();
}
break;
case OpCode.CLOSURE: {
var name = ReadConstant().CheckString().Value;
var proc = Procedure.Procedures.First(p => p.Name == name);
var upvalues = new UpValue[proc.UpValues.Length];
for (var i = 0; i < upvalues.Length; i++)
{
var pop = ReadOpCode();
if (pop != OpCode.GET_LOCAL && pop != OpCode.GET_UPVALUE)
{
throw new Exception(pop.ToString());
}
var upname = ReadConstant().CheckString().Value;
switch (pop)
{
case OpCode.GET_LOCAL: {
if (!openUps.ContainsKey(upname))
{
openUps[upname] = new UpValue(scope, upname);
}
upvalues[i] = openUps[upname];
}
break;
case OpCode.GET_UPVALUE: {
upvalues[i] = this.upvalues.First(up => up.Name == upname);
}
break;
}
}
stack.Push(new NeoBackendProcedure(VM, VM.Interpreter.Compile(scope, Chunk, proc, upvalues)));
}
break;
case OpCode.CLOSE: {
var name = ReadConstant().CheckString().Value;
if (openUps.ContainsKey(name))
{
openUps[name].Close();
openUps.Remove(name);
}
}
break;
case OpCode.GET_LOCAL: {;
stack.Push(scope.Get(ReadConstant().CheckString().Value)); }
break;
case OpCode.SET_LOCAL: {
var name = ReadConstant().CheckString().Value;
var value = stack.Pop();
scope.Set(name, value);
}
break;
case OpCode.GET_GLOBAL: {
stack.Push(ParentScope.Get(ReadConstant().CheckString().Value));
}
break;
case OpCode.SET_GLOBAL: {
ParentScope.Set(ReadConstant().CheckString().Value, stack.Pop());
}
break;
case OpCode.GET_UPVALUE: {
var name = ReadConstant().CheckString().Value;
var up = upvalues.First(u => u.Name == name);
stack.Push(up.Get());
}
break;
case OpCode.SET_UPVALUE: {
var name = ReadConstant().CheckString().Value;
var index = 0;
for (var i = 0; i < upvalues.Length; i++)
{
if (upvalues[i].Name == name)
{
index = i;
break;
}
}
upvalues[index].Set(stack.Pop());
}
break;
case OpCode.SPREAD: {
stack.Push(new NeoSpreadValue(stack.Pop().CheckArray()));
}
break;
case OpCode.FROZEN: {
stack.Push(stack.Pop().Frozen());
}
break;
case OpCode.TRY: {
var @catch = stack.Pop().CheckProcedure();
var @try = stack.Pop().CheckProcedure();
NeoValue r;
try {
r = @try.Call(new NeoValue[0]);
} catch (NeoError e) {
r = @catch.Call(new[] { NeoString.ValueOf(e.Message) });
}
if (!r.IsNil)
{
foreach (var up in openUps.Values)
{
up.Close();
}
while (defers.Count > 0)
{
defers.Pop().Call(new NeoValue[0]);
}
return(r);
}
}
break;
case OpCode.THROW: {
var line = Procedure.FindLine(ip);
throw new NeoError(stack.Pop().CheckString().Value, line);
}
case OpCode.DECLARE: {
var name = ReadConstant().CheckString().Value;
var flags = ReadByte();
scope.Declare(name, (VariableFlags)flags);
}
break;
case OpCode.PUSH_SCOPE: {
scope = new Scope(scope);
}
break;
case OpCode.POP_SCOPE: {
scope = scope.Parent;
}
break;
default: {
throw new Exception($"Unexpected opcode: {op}");
}
}
} catch (NeoError e) {
if (e.Line == -1)
{
e.Line = Procedure.FindLine(ip);
}
throw e;
}
}
throw new Exception("VM error");
}
public IEnumerable <Parameter> GetParameters(Procedure storedProcedure)
{
return(_mysqlSchemaDataProvider.GetParameters(storedProcedure));
}
/// <summary>
/// Converts all registers and stack accesses to SSA variables.
/// </summary>
/// <param name="proc"></param>
/// <returns>The SsaTransform for the procedure.</returns>
public SsaTransform ConvertToSsa(Procedure proc)
{
if (program.NeedsSsaTransform)
{
// Transform the procedure to SSA state. When encountering 'call'
// instructions, they can be to functions already visited. If so,
// they have a "ProcedureFlow" associated with them. If they have
// not been visited, or are computed destinations (e.g. vtables)
// they will have no "ProcedureFlow" associated with them yet, in
// which case the the SSA treats the call as a "hell node".
var sst = new SsaTransform(program, proc, sccProcs !, dynamicLinker, this.ProgramDataFlow);
var ssa = sst.Transform();
DumpWatchedProcedure("ssa", "After SSA", ssa.Procedure);
// Merge unaligned memory accesses.
var fuser = new UnalignedMemoryAccessFuser(ssa);
fuser.Transform();
// After value propagation expressions like (x86)
// mem[esp_42+4] will have been converted to mem[fp - 30].
// We also hope that procedure constants
// kept in registers are propagated to the corresponding call
// sites.
var vp = new ValuePropagator(program.SegmentMap, ssa, program.CallGraph, dynamicLinker, eventListener);
vp.Transform();
DumpWatchedProcedure("vp", "After first VP", ssa.Procedure);
// Fuse additions and subtractions that are linked by the carry flag.
var larw = new LongAddRewriter(ssa, eventListener);
larw.Transform();
// Propagate condition codes and registers.
var cce = new ConditionCodeEliminator(program, ssa, eventListener);
cce.Transform();
vp.Transform();
DumpWatchedProcedure("cce", "After CCE", ssa.Procedure);
// Now compute SSA for the stack-based variables as well. That is:
// mem[fp - 30] becomes wLoc30, while
// mem[fp + 30] becomes wArg30.
// This allows us to compute the dataflow of this procedure.
sst.RenameFrameAccesses = true;
sst.Transform();
DumpWatchedProcedure("ssaframe", "After SSA frame accesses", ssa.Procedure);
var icrw = new IndirectCallRewriter(program, ssa, eventListener);
while (!eventListener.IsCanceled() && icrw.Rewrite())
{
vp.Transform();
sst.RenameFrameAccesses = true;
sst.Transform();
}
var fpuGuesser = new FpuStackReturnGuesser(ssa, eventListener);
fpuGuesser.Transform();
// By placing use statements in the exit block, we will collect
// reaching definitions in the use statements.
sst.AddUsesToExitBlock();
sst.RemoveDeadSsaIdentifiers();
// Backpropagate stack pointer from procedure return.
var spBackpropagator = new StackPointerBackpropagator(ssa, eventListener);
spBackpropagator.BackpropagateStackPointer();
DumpWatchedProcedure("spbp", "After SP BP", ssa.Procedure);
// Propagate those newly created stack-based identifiers.
vp.Transform();
DumpWatchedProcedure("vp2", "After VP2", ssa.Procedure);
return(sst);
}
else
{
// We are assuming phi functions are already generated.
var sst = new SsaTransform(program, proc, sccProcs !, dynamicLinker, this.ProgramDataFlow);
return(sst);
}
}
//查询
protected void ASPxGridView1_CustomCallback(object sender, DevExpress.Web.ASPxGridView.ASPxGridViewCustomCallbackEventArgs e)
{
if (txtLSH1.Text.Trim() == "")
{
ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail");
ASPxGridView1.JSProperties.Add("cpCallbackRet", "起始流水号不能为空！");
return;
}
else if (txtLSH2.Text.Trim() == "")
{
ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail");
ASPxGridView1.JSProperties.Add("cpCallbackRet", "截止流水号不能为空！");
return;
}
int lsh1 = Convert.ToInt32(txtLSH1.Text.Trim());
int lsh2 = Convert.ToInt32(txtLSH2.Text.Trim());
string Chsql1 = "select * from DATA_PRODUCT where SN='" + txtLSH1.Text.Trim() + "' ";
DataTable Chdt1 = dc.GetTable(Chsql1);
if (Chdt1.Rows.Count <= 0)
{
ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail");
ASPxGridView1.JSProperties.Add("cpCallbackRet", "起始流水号不存在，请您重新输入！");
return;
}
string Chsql2 = "select * from DATA_PRODUCT where SN='" + txtLSH2.Text.Trim() + "' ";
DataTable Chdt2 = dc.GetTable(Chsql2);
if (Chdt2.Rows.Count <= 0)
{
ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail");
ASPxGridView1.JSProperties.Add("cpCallbackRet", "截止流水号不存在，请您重新输入！");
return;
}
if (lsh1 > lsh2)
{
ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail");
ASPxGridView1.JSProperties.Add("cpCallbackRet", "起始流水号应小于截止流水号！");
return;
}
string ZD1 = txtSCode.Text.Trim();
string sql = "", sn = "";
if (ZD1 != "")
{
sql = " select sn from DATA_SN_BOM where STATION_NAME='" + ZD1 + "' AND SN>='" + txtLSH1.Text.Trim() + "' and SN <='" + txtLSH2.Text.Trim() + "' "
+ "union select sn from DATA_SN_BOM_TEMP where STATION_NAME='" + ZD1 + "' AND SN>='" + txtLSH1.Text.Trim() + "' and SN <='" + txtLSH2.Text.Trim() + "'order by SN";
}
else
{
sql = " select sn from DATA_SN_BOM where SN>='" + txtLSH1.Text.Trim() + "' and SN <='" + txtLSH2.Text.Trim() + "' "
+ " union select sn from DATA_SN_BOM where SN>='" + txtLSH1.Text.Trim() + "' and SN <='" + txtLSH2.Text.Trim() + "'order by SN";
}
DataTable dt = dc.GetTable(sql);
for (int i = 0; i < dt.Rows.Count; i++)
{
if (i == 0)
{
dc.ExeSql("delete from DATA_SCAN_ITEM where machinename='" + MachineName + "'");
}
sn = dt.Rows[i][0].ToString();
//下边调用存储过程生成一个中间表，保存发动机的实际扫描零件清单
PL_INSERT_SJZJQD sp = new PL_INSERT_SJZJQD()
{
SN1 = sn,
MACHINENAME1 = MachineName
};
Procedure.run(sp);
}
setCondition();
ASPxGridView1.Selection.UnselectAll();
}
public override void Update(Procedure proc)
{
appl.Procedure = new ProcedureConstant(PrimitiveType.Pointer32, proc);
}
private void butGenerateClaims_Click(object sender, EventArgs e)
{
if (gridMain.SelectedIndices.Count() < 1)
{
MsgBox.Show(this, "Please select the rows for which you would like to create procedures and claims.");
return;
}
if (!MsgBox.Show(this, MsgBoxButtons.YesNo, "Are you sure you want to generate claims and procedures for all patients and insurance plans?"))
{
return;
}
List <long> listPlanNums = new List <long>();
List <long> listPatPlanNums = new List <long>();
List <long> listInsSubNums = new List <long>();
for (int i = 0; i < gridMain.SelectedIndices.Count(); i++)
{
DataRow rowCur = (DataRow)gridMain.Rows[gridMain.SelectedIndices[i]].Tag;
listPlanNums.Add(PIn.Long(rowCur["PlanNum"].ToString()));
listPatPlanNums.Add(PIn.Long(rowCur["PatPlanNum"].ToString()));
listInsSubNums.Add(PIn.Long(rowCur["InsSubNum"].ToString()));
}
List <InsPlan> listSelectedInsPlans = InsPlans.GetPlans(listPlanNums);
List <PatPlan> listSelectedPatPlans = PatPlans.GetPatPlans(listPatPlanNums);
List <InsSub> listSelectedInsSubs = InsSubs.GetMany(listInsSubNums);
List <DataRow> rowsSucceeded = new List <DataRow>();
int rowsFailed = 0;
List <Benefit> listBenefitsAll = Benefits.Refresh(listSelectedPatPlans, listSelectedInsSubs);
for (int i = 0; i < gridMain.SelectedIndices.Count(); i++)
{
try {
DataRow rowCur = (DataRow)gridMain.Rows[gridMain.SelectedIndices[i]].Tag;
long patNumCur = PIn.Long(rowCur["PatNum"].ToString());
Patient patCur = Patients.GetPat(patNumCur);
PatientNote patNoteCur = PatientNotes.Refresh(patNumCur, patCur.Guarantor);
long codeNumCur = PIn.Long(rowCur["AutoCodeNum"].ToString());
long provNumCur = PIn.Long(rowCur["ProvNum"].ToString());
long clinicNumCur = PIn.Long(rowCur["ClinicNum"].ToString());
long insPlanNumCur = PIn.Long(rowCur["PlanNum"].ToString());
long patPlanNumCur = PIn.Long(rowCur["PatPlanNum"].ToString());
long insSubNumCur = PIn.Long(rowCur["InsSubNum"].ToString());
int monthsTreat = PIn.Int(rowCur["MonthsTreat"].ToString());
DateTime dateDue = PIn.Date(rowCur["OrthoAutoNextClaimDate"].ToString());
//for each selected row
//create a procedure
//Procedures.CreateProcForPat(patNumCur,codeNumCur,"","",ProcStat.C,provNumCur);
Procedure proc = Procedures.CreateOrthoAutoProcsForPat(patNumCur, codeNumCur, provNumCur, clinicNumCur, dateDue);
InsPlan insPlanCur = InsPlans.GetPlan(insPlanNumCur, listSelectedInsPlans);
PatPlan patPlanCur = listSelectedPatPlans.FirstOrDefault(x => x.PatPlanNum == patPlanNumCur);
InsSub insSubCur = listSelectedInsSubs.FirstOrDefault(x => x.InsSubNum == insSubNumCur);
List <Benefit> benefitList = listBenefitsAll.FindAll(x => x.PatPlanNum == patPlanCur.PatPlanNum || x.PlanNum == insSubCur.PlanNum);
//create a claimproc
List <ClaimProc> listClaimProcs = new List <ClaimProc>();
Procedures.ComputeEstimates(proc, patNumCur, ref listClaimProcs, true, new List <InsPlan> {
insPlanCur
},
new List <PatPlan> {
patPlanCur
}, benefitList, null, null, true, patCur.Age, new List <InsSub> {
insSubCur
}, isForOrtho: true);
//make the feebilled == the insplan feebilled or patplan feebilled
double feebilled = patPlanCur.OrthoAutoFeeBilledOverride == -1 ? insPlanCur.OrthoAutoFeeBilled : patPlanCur.OrthoAutoFeeBilledOverride;
//create a claim with that claimproc
string claimType = "";
switch (patPlanCur.Ordinal)
{
case 1:
claimType = "P";
break;
case 2:
claimType = "S";
break;
}
DateTimeOD dateTMonthsRem = new DateTimeOD(PIn.Date(rowCur["DateBanding"].ToString()).AddMonths(PIn.Int(rowCur["MonthsTreat"].ToString())), DateTimeOD.Today);
Claims.CreateClaimForOrthoProc(claimType, patPlanCur, insPlanCur, insSubCur,
ClaimProcs.GetForProcWithOrdinal(proc.ProcNum, patPlanCur.Ordinal), proc, feebilled, PIn.Date(rowCur["DateBanding"].ToString()),
PIn.Int(rowCur["MonthsTreat"].ToString()), ((dateTMonthsRem.YearsDiff * 12) + dateTMonthsRem.MonthsDiff));
PatPlans.IncrementOrthoNextClaimDates(patPlanCur, insPlanCur, monthsTreat, patNoteCur);
rowsSucceeded.Add(rowCur);
SecurityLogs.MakeLogEntry(Permissions.ProcComplCreate, patCur.PatNum
, Lan.g(this, "Automatic ortho procedure and claim generated for") + " " + dateDue.ToShortDateString());
}
catch (Exception) {
rowsFailed++;
}
}
string message = Lan.g(this, "Done.") + " " + Lan.g(this, "There were") + " " + rowsSucceeded.Count + " "
+ Lan.g(this, "claim(s) generated and") + " " + rowsFailed + " " + Lan.g(this, "failures") + ".";
MessageBox.Show(message);
foreach (DataRow row in rowsSucceeded)
{
_tableOutstandingAutoClaims.Rows.Remove(row);
}
FillGrid();
}
public abstract void Update(Procedure proc);
public override void Update(Procedure proc)
{
ci.Callee = new ProcedureConstant(PrimitiveType.Word32, proc);
}
/// <summary>
/// Выполняет работу с записями о выполнении задачи
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected override void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e)
{
backgroundWorker.ReportProgress(50);
Invoke(new Action(() => listViewCompliance.Items.Clear()));
if (_currentDirective == null)
{
e.Cancel = true;
return;
}
List <AbstractPerformanceRecord> lastRecords = new List <AbstractPerformanceRecord>();
List <NextPerformance> nextPerformances = new List <NextPerformance>();
if (_openPubAudits == null)
{
_openPubAudits = new CommonCollection <Audit>();
}
_openPubAudits.Clear();
//_openPubAudits.AddRange(GlobalObjects.CasEnvironment.Loader.GetWorkPackages(_currentDirective.ParentBaseDetail.ParentAircraft, WorkPackageStatus.Opened, true));
//_openPubAudits.AddRange(GlobalObjects.CasEnvironment.Loader.GetWorkPackages(_currentDirective.ParentBaseDetail.ParentAircraft, WorkPackageStatus.Published, true));
_openPubAudits.AddRange(GlobalObjects.AuditCore.GetAuditsLite(_currentDirective.ParentOperator, WorkPackageStatus.Opened));
_openPubAudits.AddRange(GlobalObjects.AuditCore.GetAuditsLite(_currentDirective.ParentOperator, WorkPackageStatus.Published));
CommonCollection <Audit> allWorkPackagesIncludedTask = new CommonCollection <Audit>();
CommonCollection <Audit> openPubWorkPackages = new CommonCollection <Audit>();
CommonCollection <Audit> closedWorkPackages = new CommonCollection <Audit>();
//Поиск и заполнение просроченных директив и записей о перемещении
//Объекты для в которые будет извлекаться информация
//из записеи о перемещении
//прогнозируемый ресурс
ForecastData forecastData = null;
Aircraft parentAircraft = null;
if (_currentDirective.ParentOperator != null)
{
////если известна родительская деталь данной директивы,
////то ее текущая наработка и средняя утилизация
////используются в качестве ресурсов прогноза
////для расчета всех просроченных выполнений
//forecastData = new ForecastData(DateTime.Now,
// _currentDirective.ParentBaseDetail.AverageUtilization,
// GlobalObjects.CasEnvironment.Calculator.GetLifelength(_currentDirective.ParentBaseDetail));
//parentAircraft = _currentDirective.ParentBaseDetail.ParentAircraft;
}
//расчет след. выполнений директивы.
//если известен ресурс прогноза, то будут расчитаны все просрочнные выполнения
//если неизвестне, то только первое
GlobalObjects.PerformanceCalculator.GetNextPerformance(_currentDirective, forecastData);
nextPerformances.AddRange(_currentDirective.NextPerformances);
lastRecords.AddRange(_currentDirective.PerformanceRecords.ToArray());
////////////////////////////////////////////
//загрузка рабочих пакетов для определения
//перекрытых ими выполнений задач
//_openPubWorkPackages.AddRange(GlobalObjects.CasEnvironment.Loader.GetWorkPackages(parentAircraft, WorkPackageStatus.Opened, true));
//_openPubWorkPackages.AddRange(GlobalObjects.CasEnvironment.Loader.GetWorkPackages(parentAircraft, WorkPackageStatus.Published, true));
CommonCollection <Procedure> includedTasks = new CommonCollection <Procedure>(new[] { _currentDirective });
allWorkPackagesIncludedTask.AddRange(GlobalObjects.AuditCore.GetAuditsLite(_currentDirective.ParentOperator,
WorkPackageStatus.All,
includedTasks));
includedTasks.Clear();
#region Добавление в список просроченных выполнений
//и сравнение их с открытыми и опубликованными рабочими пакетами
openPubWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Opened ||
wp.Status == WorkPackageStatus.Published));
//сбор всех записей рабочих пакетов для удобства фильтрации
List <AuditRecord> openPubWpRecords = openPubWorkPackages.SelectMany(wp => wp.AuditRecords).ToList();
//LINQ запрос для сортировки записей по дате
List <NextPerformance> sortNextRecords = (from record in nextPerformances
orderby GetDate(record) descending
select record).ToList();
for (int i = 0; i < sortNextRecords.Count; i++)
{
if (backgroundWorker.CancellationPending)
{
allWorkPackagesIncludedTask.Clear();
openPubWorkPackages.Clear();
closedWorkPackages.Clear();
e.Cancel = true;
return;
}
//поиск записи в рабочих пакетах по данному чеку
//чей номер группы выполнения (по записи) совпадает с расчитанным
Procedure directive = (Procedure)sortNextRecords[i].Parent;
//номер выполнения
int parentCountPerf;
if (directive.LastPerformance != null)
{
parentCountPerf = directive.LastPerformance.PerformanceNum <= 0
? 1
: directive.LastPerformance.PerformanceNum;
}
else
{
parentCountPerf = 0;
}
parentCountPerf += directive.NextPerformances.IndexOf(sortNextRecords[i]);
parentCountPerf += 1;
AuditRecord wpr =
openPubWpRecords.FirstOrDefault(r => r.PerformanceNumFromStart == parentCountPerf &&
r.AuditItemTypeId == directive.SmartCoreObjectType.ItemId &&
r.DirectiveId == directive.ItemId);
if (wpr != null)
{
Audit wp = openPubWorkPackages.GetItemById(wpr.AuditId);
//запись о выполнении блокируется найденым пакетом
sortNextRecords[i].BlockedByPackage = wp;
//последующие записи о выполнении так же должны быть заблокированы
for (int j = i - 1; j >= 0; j--)
{
//блокировать нужно все рабочие записи, или до первой записи,
//заблокированной другим рабочим пакетом
if (sortNextRecords[j].BlockedByPackage != null ||
sortNextRecords[j].Condition != ConditionState.Overdue)
{
break;
}
if (sortNextRecords[j].Parent == directive)
{
sortNextRecords[j].BlockedByPackage = wp;
Invoke(new Action <int, Color>(SetItemColor), new object[] { j, Color.FromArgb(Highlight.GrayLight.Color) });
}
}
}
Invoke(new Action <NextPerformance>(AddListViewItem), sortNextRecords[i]);
}
#endregion
#region Добавление в список записей о произведенных выполнениях
//и сравнение их с закрытыми рабочими пакетами
closedWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Closed));
//LINQ запрос для сортировки записей по дате
List <AbstractPerformanceRecord> sortLastRecords = (from record in lastRecords
orderby record.RecordDate descending
select record).ToList();
////////////////////////////////////////////
for (int i = 0; i < sortLastRecords.Count(); i++)
{
if (backgroundWorker.CancellationPending)
{
allWorkPackagesIncludedTask.Clear();
openPubWorkPackages.Clear();
closedWorkPackages.Clear();
e.Cancel = true;
return;
}
DirectiveRecord directiveRecord = (DirectiveRecord)sortLastRecords[i];
Audit workPackage = closedWorkPackages.FirstOrDefault(wp => wp.ItemId == directiveRecord.DirectivePackageId);
if (workPackage != null)
{
Invoke(new Action <AbstractPerformanceRecord, Audit, MaintenanceCheckRecord>(AddListViewItem),
new object[] { sortLastRecords[i], workPackage, null });
}
else if (directiveRecord.MaintenanceCheckRecordId > 0)
{
MaintenanceCheckRecord mcr =
GlobalObjects.CasEnvironment.NewLoader.GetObject <DirectiveRecordDTO, MaintenanceCheckRecord>(new Filter("ItemId", directiveRecord.MaintenanceCheckRecordId));
if (mcr != null)
{
mcr.ParentCheck = GlobalObjects.CasEnvironment.NewLoader.GetObjectById <MaintenanceCheckDTO, MaintenanceCheck>(mcr.ParentId);
}
Invoke(new Action <AbstractPerformanceRecord, Audit, MaintenanceCheckRecord>(AddListViewItem),
new object[] { sortLastRecords[i], workPackage, mcr });
}
else
{
Invoke(new Action <AbstractPerformanceRecord, Audit>(AddListViewItem),
new object[] { sortLastRecords[i], workPackage });
}
}
#endregion
allWorkPackagesIncludedTask.Clear();
openPubWorkPackages.Clear();
closedWorkPackages.Clear();
backgroundWorker.ReportProgress(100);
}
public static void Remove(Procedure p)
{
var uvr = new UnusedSymbolRemover(p);
foreach (var bb in p.cfg.nodes)
{
foreach (var si in bb.statements)
{
uvr.visit(si.statementId);
}
}
foreach (var ft in p.parentScope.functionTemplates)
{
ft.signature.resultType.visit(uvr);
foreach (var at in ft.signature.argumentTypes)
{
at.visit(uvr);
}
}
foreach (var v in p.parentScope.locals)
{
v.type.visit(uvr);
}
foreach (var v in p.locals)
{
v.type.visit(uvr);
}
foreach (var v in p.inputs)
{
v.type.visit(uvr);
}
foreach (var v in p.outputs)
{
v.type.visit(uvr);
}
// foreach (var e in ( from ft in p.parentScope.functionTemplates where ft.fae!=null select ft.fae))
// e.visitI(uvr);
var deleted = new HashSet <StatementId>();
foreach (var f in uvr.functionOccurences)
{
if (f.Value.Count == 1 && !ExpressionSymbolCounter.isInterpreted(f.Key) &&
!deleted.Contains(f.Value.First().Value))
{
Expression e = f.Value.First().Key.expression;
// Console.WriteLine("Function {0} has one occurence: {1}", f.Key, e.ToString());
Expression qe = e;
while (qe is QuantifiedTypeExpression)
{
qe = (qe as QuantifiedTypeExpression).expression;
}
while (qe is QuantifiedExpression)
{
qe = (qe as QuantifiedExpression).expression;
}
var fae = qe as FAE;
if (fae != null)
{
if (BFunction.isEquality(fae.function) || BFunction.isEquivalence(fae.function) ||
BFunction.isImplication(fae.function))
{
var a0fae = fae.arguments[0] as FAE;
while (a0fae != null &&
(BFunction.isMapRead(a0fae.function) || BFunction.isCoerce(a0fae.function) ||
(a0fae.arguments.count == 1 && a0fae.function.name != f.Key)))
{
a0fae = a0fae.arguments[0] as FAE;
}
var a1fae = fae.arguments[1] as FAE;
while (a1fae != null &&
(BFunction.isMapRead(a1fae.function) || BFunction.isCoerce(a1fae.function) ||
(a1fae.arguments.count == 1 && a1fae.function.name != f.Key)))
{
a1fae = a1fae.arguments[0] as FAE;
}
if ((a0fae != null && a0fae.function.name == f.Key) ^
(a1fae != null && a1fae.function.name == f.Key))
{
// Console.WriteLine("\tDefinition - can be removed safely");
uvr.unusedFunctions.Add(f.Key);
deleted.Add(f.Value.First().Value);
f.Value.First().Value.delete();
}
}
}
}
}
///////////////////////////////////////////////////////////
foreach (var v in uvr.unusedVariables)
{
if (p.tryFindVariable(v) != null)
{
p.removeVariable(v);
}
else
{
p.parentScope.removeVariable(v);
}
}
foreach (var f in uvr.unusedFunctions)
{
p.removeFunctionTemplate(f);
}
foreach (var tc in uvr.unusedTypeConstructors)
{
p.removeTypeConstructor(tc);
}
foreach (var ts in uvr.unusedTypeSynonyms)
{
p.removeTypeSynonym(ts);
}
// return uvr;
}
public AtomicActionInfo(Procedure proc, Ensures ensures, MoverType moverType, int layerNum, int availableUptoLayerNum)
: base(proc, layerNum, availableUptoLayerNum)
{
this.ensures = ensures;
this.moverType = moverType;
this.gate = new List <AssertCmd>();
this.action = ensures.Condition as CodeExpr;
this.thisGate = new List <AssertCmd>();
this.thisInParams = new List <Variable>();
this.thisOutParams = new List <Variable>();
this.thatGate = new List <AssertCmd>();
this.thatInParams = new List <Variable>();
this.thatOutParams = new List <Variable>();
this.hasAssumeCmd = false;
this.thisMap = new Dictionary <Variable, Expr>();
this.thatMap = new Dictionary <Variable, Expr>();
foreach (Block block in this.action.Blocks)
{
block.Cmds.ForEach(x => this.hasAssumeCmd = this.hasAssumeCmd || x is AssumeCmd);
}
foreach (Block block in this.action.Blocks)
{
if (block.TransferCmd is ReturnExprCmd)
{
block.TransferCmd = new ReturnCmd(block.TransferCmd.tok);
}
}
var cmds = this.action.Blocks[0].Cmds;
for (int i = 0; i < cmds.Count; i++)
{
AssertCmd assertCmd = cmds[i] as AssertCmd;
if (assertCmd == null)
{
break;
}
this.gate.Add(assertCmd);
cmds[i] = new AssumeCmd(assertCmd.tok, Expr.True);
}
foreach (Variable x in proc.InParams)
{
Variable thisx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "this_" + x.Name, x.TypedIdent.Type), true, x.Attributes);
this.thisInParams.Add(thisx);
this.thisMap[x] = Expr.Ident(thisx);
Variable thatx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), true, x.Attributes);
this.thatInParams.Add(thatx);
this.thatMap[x] = Expr.Ident(thatx);
}
foreach (Variable x in proc.OutParams)
{
Variable thisx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "this_" + x.Name, x.TypedIdent.Type), false, x.Attributes);
this.thisOutParams.Add(thisx);
this.thisMap[x] = Expr.Ident(thisx);
Variable thatx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), false, x.Attributes);
this.thatOutParams.Add(thatx);
this.thatMap[x] = Expr.Ident(thatx);
}
List <Variable> thisLocVars = new List <Variable>();
List <Variable> thatLocVars = new List <Variable>();
foreach (Variable x in this.action.LocVars)
{
Variable thisx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "this_" + x.Name, x.TypedIdent.Type), false);
thisMap[x] = Expr.Ident(thisx);
thisLocVars.Add(thisx);
Variable thatx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), false);
thatMap[x] = Expr.Ident(thatx);
thatLocVars.Add(thatx);
}
Contract.Assume(proc.TypeParameters.Count == 0);
Substitution thisSubst = Substituter.SubstitutionFromHashtable(this.thisMap);
Substitution thatSubst = Substituter.SubstitutionFromHashtable(this.thatMap);
foreach (AssertCmd assertCmd in this.gate)
{
this.thisGate.Add((AssertCmd)Substituter.Apply(thisSubst, assertCmd));
this.thatGate.Add((AssertCmd)Substituter.Apply(thatSubst, assertCmd));
}
this.thisAction = new CodeExpr(thisLocVars, SubstituteBlocks(this.action.Blocks, thisSubst, "this_"));
this.thatAction = new CodeExpr(thatLocVars, SubstituteBlocks(this.action.Blocks, thatSubst, "that_"));
{
VariableCollector collector = new VariableCollector();
collector.Visit(this.action);
this.actionUsedGlobalVars = new HashSet <Variable>(collector.usedVars.Where(x => x is GlobalVariable));
}
List <Variable> modifiedVars = new List <Variable>();
foreach (Block block in this.action.Blocks)
{
block.Cmds.ForEach(cmd => cmd.AddAssignedVariables(modifiedVars));
}
this.modifiedGlobalVars = new HashSet <Variable>(modifiedVars.Where(x => x is GlobalVariable));
{
VariableCollector collector = new VariableCollector();
this.gate.ForEach(assertCmd => collector.Visit(assertCmd));
this.gateUsedGlobalVars = new HashSet <Variable>(collector.usedVars.Where(x => x is GlobalVariable));
}
}
private void AddPerformance()
{
if (listViewCompliance.SelectedItems.Count == 0)
{
return;
}
DirectiveComplianceDialog dlg;
DirectiveRecord record;
NextPerformance np;
if (listViewCompliance.SelectedItems[0].Tag is NextPerformance)
{
//if (_currentDirective.MaintenanceCheck != null)
//{
// MessageBox.Show("This MPD is binded to maintenance check '" + _currentDirective.MaintenanceCheck.Name + "'." +
// "\nPerformance for this item introduced by performance of maintenance check.",
// (string)new GlobalTermsProvider()["SystemName"],
// MessageBoxButtons.OK,
// MessageBoxIcon.Warning,
// MessageBoxDefaultButton.Button1);
// return;
//}
np = (NextPerformance)listViewCompliance.SelectedItems[0].Tag;
if (np.Condition != ConditionState.Overdue || np.PerformanceDate > DateTime.Now)
{
MessageBox.Show("You can not enter a record for not delayed performance",
(string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.OK,
MessageBoxIcon.Warning,
MessageBoxDefaultButton.Button1);
return;
}
if (np.BlockedByPackage != null)
{
MessageBox.Show("Perform of the task:" + listViewCompliance.SelectedItems[0].Text +
"\nblocked by Package:" +
"\n" + np.BlockedByPackage.Title,
(string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.OK,
MessageBoxIcon.Warning,
MessageBoxDefaultButton.Button1);
return;
}
dlg = new DirectiveComplianceDialog(np.Parent, np)
{
Text = "Add new compliance for " + np.WorkType
};
dlg.ShowDialog();
if (dlg.DialogResult == DialogResult.OK)
{
InvokeComplianceAdded(null);
}
}
else if (listViewCompliance.SelectedItems[0].Tag is DirectiveRecord)
{
record = (DirectiveRecord)listViewCompliance.SelectedItems[0].Tag;
IDirective directive = record.Parent;
if (directive is Procedure)
{
Procedure parentDirective = (Procedure)directive;
dlg = new DirectiveComplianceDialog(record.Parent, record)
{
Text = "Edit exist compliance for " + parentDirective.ProcedureType
};
dlg.ShowDialog();
if (dlg.DialogResult == DialogResult.OK)
{
InvokeComplianceAdded(null);
}
}
else if (directive is ComponentDirective)
{
ComponentDirective parentDirective = (ComponentDirective)directive;
dlg = new DirectiveComplianceDialog(record.Parent, record)
{
Text = "Edit exist compliance for " + parentDirective.DirectiveType + " of " + parentDirective.ParentComponent.Description
};
dlg.ShowDialog();
if (dlg.DialogResult == DialogResult.OK)
{
InvokeComplianceAdded(null);
}
}
}
else
{
return;
}
}
public override Procedure VisitProcedure(Procedure node)
{
node.Attributes = RemoveLayerAttribute(node.Attributes);
return(base.VisitProcedure(node));
}
public void TypeCheck()
{
foreach (var proc in program.Procedures)
{
if (!QKeyValue.FindBoolAttribute(proc.Attributes, "pure"))
{
continue;
}
if (QKeyValue.FindBoolAttribute(proc.Attributes, "yields"))
{
Error(proc, "Pure procedure must not yield");
continue;
}
if (QKeyValue.FindBoolAttribute(proc.Attributes, "layer"))
{
Error(proc, "Pure procedure must not have layers");
continue;
}
if (proc.Modifies.Count > 0)
{
Error(proc, "Pure procedure must not modify a global variable");
continue;
}
procToAtomicProcedureInfo[proc] = new AtomicProcedureInfo();
}
foreach (var proc in program.Procedures)
{
if (QKeyValue.FindBoolAttribute(proc.Attributes, "yields"))
{
continue;
}
var procLayerNums = FindLayers(proc.Attributes);
if (procLayerNums.Count == 0)
{
continue;
}
foreach (IdentifierExpr ie in proc.Modifies)
{
if (!globalVarToSharedVarInfo.ContainsKey(ie.Decl))
{
Error(proc, "Atomic procedure cannot modify a global variable without layer numbers");
continue;
}
}
int lower, upper;
if (procLayerNums.Count == 1)
{
lower = procLayerNums[0];
upper = procLayerNums[0];
}
else if (procLayerNums.Count == 2)
{
lower = procLayerNums[0];
upper = procLayerNums[1];
if (lower >= upper)
{
Error(proc, "Lower layer must be less than upper layer");
continue;
}
}
else
{
Error(proc, "Atomic procedure must specify a layer range");
continue;
}
LayerRange layerRange = new LayerRange(lower, upper);
procToAtomicProcedureInfo[proc] = new AtomicProcedureInfo(layerRange);
}
if (errorCount > 0)
{
return;
}
foreach (Implementation impl in program.Implementations)
{
if (!procToAtomicProcedureInfo.ContainsKey(impl.Proc))
{
continue;
}
var atomicProcedureInfo = procToAtomicProcedureInfo[impl.Proc];
if (atomicProcedureInfo.isPure)
{
this.enclosingImpl = impl;
(new PurityChecker(this)).VisitImplementation(impl);
}
else
{
this.enclosingImpl = impl;
this.sharedVarsAccessed = new HashSet <Variable>();
(new PurityChecker(this)).VisitImplementation(impl);
LayerRange upperBound = FindLayerRange();
LayerRange lowerBound = atomicProcedureInfo.layerRange;
if (!lowerBound.Subset(upperBound))
{
Error(impl, "Atomic procedure cannot access global variable");
}
this.sharedVarsAccessed = null;
}
}
if (errorCount > 0)
{
return;
}
foreach (var proc in program.Procedures)
{
if (!QKeyValue.FindBoolAttribute(proc.Attributes, "yields"))
{
continue;
}
int createdAtLayerNum; // must be initialized by the following code, otherwise it is an error
int availableUptoLayerNum = int.MaxValue;
List <int> attrs = FindLayers(proc.Attributes);
if (attrs.Count == 1)
{
createdAtLayerNum = attrs[0];
}
else if (attrs.Count == 2)
{
createdAtLayerNum = attrs[0];
availableUptoLayerNum = attrs[1];
}
else
{
Error(proc, "Incorrect number of layers");
continue;
}
foreach (Ensures e in proc.Ensures)
{
MoverType moverType = GetMoverType(e);
if (moverType == MoverType.Top)
{
continue;
}
CodeExpr codeExpr = e.Condition as CodeExpr;
if (codeExpr == null)
{
Error(e, "An atomic action must be a CodeExpr");
continue;
}
if (procToActionInfo.ContainsKey(proc))
{
Error(proc, "A procedure can have at most one atomic action");
continue;
}
if (availableUptoLayerNum <= createdAtLayerNum)
{
Error(proc, "Creation layer number must be less than the available upto layer number");
continue;
}
sharedVarsAccessed = new HashSet <Variable>();
enclosingProc = proc;
enclosingImpl = null;
base.VisitEnsures(e);
LayerRange upperBound = FindLayerRange();
LayerRange lowerBound = new LayerRange(createdAtLayerNum, availableUptoLayerNum);
if (lowerBound.Subset(upperBound))
{
procToActionInfo[proc] = new AtomicActionInfo(proc, e, moverType, createdAtLayerNum, availableUptoLayerNum);
}
else
{
Error(e, "A variable being accessed in this action is unavailable");
}
sharedVarsAccessed = null;
}
if (errorCount > 0)
{
continue;
}
if (!procToActionInfo.ContainsKey(proc))
{
if (availableUptoLayerNum < createdAtLayerNum)
{
Error(proc, "Creation layer number must be no more than the available upto layer number");
continue;
}
else
{
procToActionInfo[proc] = new ActionInfo(proc, createdAtLayerNum, availableUptoLayerNum);
}
}
}
if (errorCount > 0)
{
return;
}
foreach (var impl in program.Implementations)
{
if (!procToActionInfo.ContainsKey(impl.Proc))
{
continue;
}
ActionInfo actionInfo = procToActionInfo[impl.Proc];
procToActionInfo[impl.Proc].hasImplementation = true;
if (actionInfo.isExtern)
{
Error(impl.Proc, "Extern procedure cannot have an implementation");
}
}
if (errorCount > 0)
{
return;
}
foreach (Procedure proc in procToActionInfo.Keys)
{
for (int i = 0; i < proc.InParams.Count; i++)
{
Variable v = proc.InParams[i];
var layer = FindLocalVariableLayer(proc, v, procToActionInfo[proc].createdAtLayerNum);
if (layer == int.MinValue)
{
continue;
}
localVarToLocalVariableInfo[v] = new LocalVariableInfo(layer);
}
for (int i = 0; i < proc.OutParams.Count; i++)
{
Variable v = proc.OutParams[i];
var layer = FindLocalVariableLayer(proc, v, procToActionInfo[proc].createdAtLayerNum);
if (layer == int.MinValue)
{
continue;
}
localVarToLocalVariableInfo[v] = new LocalVariableInfo(layer);
}
}
foreach (Implementation node in program.Implementations)
{
if (!procToActionInfo.ContainsKey(node.Proc))
{
continue;
}
foreach (Variable v in node.LocVars)
{
var layer = FindLocalVariableLayer(node, v, procToActionInfo[node.Proc].createdAtLayerNum);
if (layer == int.MinValue)
{
continue;
}
localVarToLocalVariableInfo[v] = new LocalVariableInfo(layer);
}
for (int i = 0; i < node.Proc.InParams.Count; i++)
{
Variable v = node.Proc.InParams[i];
if (!localVarToLocalVariableInfo.ContainsKey(v))
{
continue;
}
var layer = localVarToLocalVariableInfo[v].layer;
localVarToLocalVariableInfo[node.InParams[i]] = new LocalVariableInfo(layer);
}
for (int i = 0; i < node.Proc.OutParams.Count; i++)
{
Variable v = node.Proc.OutParams[i];
if (!localVarToLocalVariableInfo.ContainsKey(v))
{
continue;
}
var layer = localVarToLocalVariableInfo[v].layer;
localVarToLocalVariableInfo[node.OutParams[i]] = new LocalVariableInfo(layer);
}
}
if (errorCount > 0)
{
return;
}
this.VisitProgram(program);
if (errorCount > 0)
{
return;
}
YieldTypeChecker.PerformYieldSafeCheck(this);
new LayerEraser().VisitProgram(program);
}
public MapWriteRemover(Procedure procedure, TypeInstanceCollector tic)
: base(procedure)
{
this.tic = tic;
}
public static void remove(Procedure procedure, TypeInstanceCollector tic)
{
new MapWriteRemover(procedure, tic).remove();
}
public void Claims_CalculateAndUpdate_Allowed1Allowed2CompletedProcedures()
{
string suffix = "8";
Patient pat = PatientT.CreatePatient(suffix);
long patNum = pat.PatNum;
long feeSchedNum1 = FeeSchedT.CreateFeeSched(FeeScheduleType.Normal, suffix);
long feeSchedNum2 = FeeSchedT.CreateFeeSched(FeeScheduleType.Normal, suffix + "b");
//Standard Fee
long codeNum = ProcedureCodes.GetCodeNum("D2750");
Fee fee = Fees.GetFee(codeNum, 53, 0, 0);
if (fee == null)
{
fee = new Fee();
fee.CodeNum = codeNum;
fee.FeeSched = 53;
fee.Amount = 1200;
Fees.Insert(fee);
}
else
{
fee.Amount = 1200;
Fees.Update(fee);
}
//PPO fees
fee = new Fee();
fee.CodeNum = codeNum;
fee.FeeSched = feeSchedNum1;
fee.Amount = 600;
Fees.Insert(fee);
fee = new Fee();
fee.CodeNum = codeNum;
fee.FeeSched = feeSchedNum2;
fee.Amount = 800;
Fees.Insert(fee);
//Carrier
Carrier carrier = CarrierT.CreateCarrier(suffix);
long planNum1 = InsPlanT.CreateInsPlanPPO(carrier.CarrierNum, feeSchedNum1).PlanNum;
long planNum2 = InsPlanT.CreateInsPlanPPO(carrier.CarrierNum, feeSchedNum2).PlanNum;
InsSub sub1 = InsSubT.CreateInsSub(pat.PatNum, planNum1);
long subNum1 = sub1.InsSubNum;
InsSub sub2 = InsSubT.CreateInsSub(pat.PatNum, planNum2);
long subNum2 = sub2.InsSubNum;
BenefitT.CreateCategoryPercent(planNum1, EbenefitCategory.Crowns, 50);
BenefitT.CreateCategoryPercent(planNum2, EbenefitCategory.Crowns, 50);
BenefitT.CreateAnnualMax(planNum1, 1000);
BenefitT.CreateAnnualMax(planNum2, 1000);
PatPlanT.CreatePatPlan(1, patNum, subNum1);
PatPlanT.CreatePatPlan(2, patNum, subNum2);
Procedure proc = ProcedureT.CreateProcedure(pat, "D2750", ProcStat.TP, "8", Fees.GetAmount0(codeNum, 53)); //crown on 8
long procNum = proc.ProcNum;
//Lists
List <ClaimProc> claimProcs = ClaimProcs.Refresh(patNum);
Family fam = Patients.GetFamily(patNum);
List <InsSub> subList = InsSubs.RefreshForFam(fam);
List <InsPlan> planList = InsPlans.RefreshForSubList(subList);
List <PatPlan> patPlans = PatPlans.Refresh(patNum);
List <Benefit> benefitList = Benefits.Refresh(patPlans, subList);
List <Procedure> procList = Procedures.Refresh(patNum);
//Set complete and attach to claim
ProcedureT.SetComplete(proc, pat, planList, patPlans, claimProcs, benefitList, subList);
claimProcs = ClaimProcs.Refresh(patNum);
List <Procedure> procsForClaim = new List <Procedure>();
procsForClaim.Add(proc);
Claim claim = ClaimT.CreateClaim("P", patPlans, planList, claimProcs, procList, pat, procsForClaim, benefitList, subList);
//Validate
Assert.AreEqual(500, claim.WriteOff);
}
protected void ASPxGridView1_CustomCallback(object sender, DevExpress.Web.ASPxGridView.ASPxGridViewCustomCallbackEventArgs e)
{
if (ASPxDateEdit1.Date.AddDays(31) < ASPxDateEdit2.Date)
{
ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail");
ASPxGridView1.JSProperties.Add("cpCallbackRet", "选择日期范围不能超过30天，请重新选择！");
return;
}
//判断是否改制发动机
if (txtSN.Text.Trim() != "")
{
string gzsql = "select a.plan_type from data_plan a left join data_plan_sn b on a.plan_code=b.plan_code where b.sn='" + txtSN.Text.Trim() + "'";
string type = dc.GetValue(gzsql);
if (type != "C" || type != "D")
{
//弹出提示框不是改制流水号
ASPxGridView1.JSProperties.Add("cpCallbackName", "Fail");
ASPxGridView1.JSProperties.Add("cpCallbackRet", "该流水号不是改制流水号，请您重新输入！");
return;
}
//下边程序动态生成一个中间表，保存发动机的实际扫描零件清单
dc.ExeSql("delete from DATA_SCAN_ITEM where machinename='" + MachineName + "'");
PL_INSERT_SJZJQD sp = new PL_INSERT_SJZJQD()
{
SN1 = txtSN.Text.Trim(),
MACHINENAME1 = MachineName
};
Procedure.run(sp);
}
else
{
string datetime = ASPxDateEdit2.Date.ToShortDateString() + " 23:59:59";
string sql = " select sn from DATA_SN_BOM where sn in( select b.sn from data_plan a left join data_plan_sn b on a.plan_code=b.plan_code where (a.plan_type='C' or a.plan_type='D')) ";
if (ASPxDateEdit1.Text.Trim() != "")
{
sql = sql + " and CREATE_TIME>=to_date('" + ASPxDateEdit1.Text.Trim() + "','yyyy-mm-dd hh24:mi:ss')";
}
if (ASPxDateEdit2.Text.Trim() != "")
{
sql = sql + " and CREATE_TIME<=to_date('" + datetime + "','yyyy-mm-dd hh24:mi:ss')";
}
sql = sql + "union select sn from DATA_SN_BOM_TEMP where sn in( select sn from data_record )";
if (ASPxDateEdit1.Text.Trim() != "")
{
sql = sql + " and CREATE_TIME>=to_date('" + ASPxDateEdit1.Text.Trim() + "','yyyy-mm-dd hh24:mi:ss')";
}
if (ASPxDateEdit2.Text.Trim() != "")
{
sql = sql + " and CREATE_TIME<=to_date('" + datetime + "','yyyy-mm-dd hh24:mi:ss')";
}
sql = sql + " order by SN";
DataTable dt = dc.GetTable(sql);
for (int i = 0; i < dt.Rows.Count; i++)
{
//if (i == 0) { dc.ExeSql("delete from DATA_SCAN_ITEM where machinename='" + MachineName + "'"); }
string sn = dt.Rows[i][0].ToString();
//下边调用存储过程生成一个中间表，保存发动机的实际扫描零件清单
PL_INSERT_SJZJQD sp = new PL_INSERT_SJZJQD()
{
SN1 = sn,
MACHINENAME1 = MachineName
};
Procedure.run(sp);
}
}
setCondition();
}
public IntroductionAction(Procedure proc, Implementation impl, LayerRange layerRange) :
base(proc, impl, layerRange)
{
}
///<summary>Most of the logic for breaking an appointment. Pass in the brokenFee (the number the user enters in the brokenAppointment window),
///Optionally pass in if the brokenappointment procedure is being deleted. Returns the broken procedure that was created.</summary>
public static Procedure BreakAppointment(Appointment appt, Patient pat, ProcedureCode procCode, double feeOverride, bool isDeleteBrokenProc = false)
{
//suppressHistory is true due to below logic creating a log with a specific HistAppointmentAction instead of the generic changed.
DateTime datePrevious = appt.DateTStamp;
bool suppressHistory = false;
if (procCode != null)
{
suppressHistory = procCode.ProcCode == "D9986" || procCode.ProcCode == "D9987";
}
Appointments.SetAptStatus(appt, ApptStatus.Broken, suppressHistory); //Appointments S-Class handles Signalods
if (appt.AptStatus != ApptStatus.Complete) //seperate log entry for completed appointments.
{
SecurityLogs.MakeLogEntry(Permissions.AppointmentEdit, pat.PatNum,
appt.ProcDescript + ", " + appt.AptDateTime.ToString()
+ ", Broken from the Appts module.", appt.AptNum, datePrevious);
}
else
{
SecurityLogs.MakeLogEntry(Permissions.AppointmentCompleteEdit, pat.PatNum,
appt.ProcDescript + ", " + appt.AptDateTime.ToString()
+ ", Broken from the Appts module.", appt.AptNum, datePrevious);
}
List <Procedure> listProcedures = Procedures.GetProcsForSingle(appt.AptNum, false);
//splits should only exist on procs if they are using tp pre-payments
List <PaySplit> listSplitsForApptProcs = new List <PaySplit>();
bool isNonRefundable = false;
double brokenProcAmount = 0;
if (listProcedures.Count > 0)
{
listSplitsForApptProcs = PaySplits.GetPaySplitsFromProcs(listProcedures.Select(x => x.ProcNum).ToList());
}
Procedure brokenProcedure = new Procedure();
#region Charting the proc
if (procCode != null)
{
switch (procCode.ProcCode)
{
case "D9986": //Missed
HistAppointments.CreateHistoryEntry(appt.AptNum, HistAppointmentAction.Missed);
break;
case "D9987": //Cancelled
HistAppointments.CreateHistoryEntry(appt.AptNum, HistAppointmentAction.Cancelled);
break;
}
brokenProcedure.PatNum = pat.PatNum;
brokenProcedure.ProvNum = (procCode.ProvNumDefault > 0 ? procCode.ProvNumDefault : appt.ProvNum);
brokenProcedure.CodeNum = procCode.CodeNum;
brokenProcedure.ProcDate = DateTime.Today;
brokenProcedure.DateEntryC = DateTime.Now;
brokenProcedure.ProcStatus = ProcStat.C;
brokenProcedure.ClinicNum = appt.ClinicNum;
brokenProcedure.UserNum = Security.CurUser.UserNum;
brokenProcedure.Note = Lans.g("AppointmentEdit", "Appt BROKEN for") + " " + appt.ProcDescript + " " + appt.AptDateTime.ToString();
brokenProcedure.PlaceService = (PlaceOfService)PrefC.GetInt(PrefName.DefaultProcedurePlaceService); //Default proc place of service for the Practice is used.
List <InsSub> listInsSubs = InsSubs.RefreshForFam(Patients.GetFamily(pat.PatNum));
List <InsPlan> listInsPlans = InsPlans.RefreshForSubList(listInsSubs);
List <PatPlan> listPatPlans = PatPlans.Refresh(pat.PatNum);
InsPlan insPlanPrimary = null;
InsSub insSubPrimary = null;
if (listPatPlans.Count > 0)
{
insSubPrimary = InsSubs.GetSub(listPatPlans[0].InsSubNum, listInsSubs);
insPlanPrimary = InsPlans.GetPlan(insSubPrimary.PlanNum, listInsPlans);
}
double procFee;
long feeSch;
if (insPlanPrimary == null || procCode.NoBillIns)
{
feeSch = FeeScheds.GetFeeSched(0, pat.FeeSched, brokenProcedure.ProvNum);
}
else //Only take into account the patient's insurance fee schedule if the D9986 procedure is not marked as NoBillIns
{
feeSch = FeeScheds.GetFeeSched(insPlanPrimary.FeeSched, pat.FeeSched, brokenProcedure.ProvNum);
}
procFee = Fees.GetAmount0(brokenProcedure.CodeNum, feeSch, brokenProcedure.ClinicNum, brokenProcedure.ProvNum);
if (insPlanPrimary != null && insPlanPrimary.PlanType == "p" && !insPlanPrimary.IsMedical) //PPO
{
double provFee = Fees.GetAmount0(brokenProcedure.CodeNum, Providers.GetProv(brokenProcedure.ProvNum).FeeSched, brokenProcedure.ClinicNum,
brokenProcedure.ProvNum);
brokenProcedure.ProcFee = Math.Max(provFee, procFee);
}
else
{
brokenProcedure.ProcFee = procFee;
}
if (!PrefC.GetBool(PrefName.EasyHidePublicHealth))
{
brokenProcedure.SiteNum = pat.SiteNum;
}
Procedures.Insert(brokenProcedure);
Procedure procOld = brokenProcedure.Copy();
//Now make a claimproc if the patient has insurance. We do this now for consistency because a claimproc could get created in the future.
List <Benefit> listBenefits = Benefits.Refresh(listPatPlans, listInsSubs);
List <ClaimProc> listClaimProcsForProc = ClaimProcs.RefreshForProc(brokenProcedure.ProcNum);
Procedures.ComputeEstimates(brokenProcedure, pat.PatNum, listClaimProcsForProc, false, listInsPlans, listPatPlans, listBenefits, pat.Age, listInsSubs);
if (listSplitsForApptProcs.Count > 0 && PrefC.GetBool(PrefName.TpPrePayIsNonRefundable) && procCode.ProcCode == "D9986")
{
//if there are pre-payments, non-refundable pre-payments is turned on, and the broken appointment is a missed code then auto-fill
//the window with the sum of the procs for the appointment. Transfer money below after broken procedure is confirmed by the user.
//normally goes to the form to let the user speficy, this is the auto filled amount for the form.
brokenProcedure.ProcFee = feeOverride; //listSplitsForApptProcs.Sum(x => x.SplitAmt);
isNonRefundable = true;
}
if (isDeleteBrokenProc)
{
brokenProcedure.ProcStatus = ProcStat.D;
}
brokenProcedure.ProcFee = feeOverride;
brokenProcAmount = feeOverride;
Procedures.Update(brokenProcedure, procOld);
}
#endregion
//Note this MUST come after FormProcBroken since clicking cancel in that window will delete the procedure.
if (isNonRefundable && !isDeleteBrokenProc && listSplitsForApptProcs.Count > 0)
{
//transfer what the user specified in the broken appointment window.
//transfer up to the amount specified by the user
foreach (Procedure proc in listProcedures)
{
if (brokenProcAmount == 0)
{
break;
}
List <PaySplit> listSplitsForAppointmentProcedure = listSplitsForApptProcs.FindAll(x => x.ProcNum == proc.ProcNum);
foreach (PaySplit split in listSplitsForAppointmentProcedure)
{
if (brokenProcAmount == 0)
{
break;
}
double amt = Math.Min(brokenProcAmount, split.SplitAmt);
Payments.CreateTransferForTpProcs(proc, new List <PaySplit> {
split
}, brokenProcedure, amt);
brokenProcAmount -= amt;
}
}
}
return(brokenProcedure);
}
public LemmaProc(Procedure proc)
{
this.proc = proc;
}
public IBlockNameDialog CreateBlockNameDialog(Procedure proc, Block block)
{
var dlg = new BlockNameDialog(proc, block);
return(dlg);
}
// Check account existence
// Get all users
public DataTable DoQuery()
{
_dbConnector.Connect();
DataSet dataset = new DataSet("MainDataset");
_dataTable = new DataTable();
_dataTable = dataset.Tables.Add("MainTable");
MySqlCommand command = new MySqlCommand(Procedure, _dbConnector.DbConnectionInstance)
{
CommandType = CommandType.StoredProcedure
};
if (Parameters?.Count > 0)
{
foreach (var parameter in Parameters)
{
command.Parameters.AddWithValue(parameter.Key, parameter.Value);
}
}
using (MySqlDataReader reader = command.ExecuteReader()) {
if (!reader.HasRows)
{
return(null);
}
int columCount = reader.FieldCount;
for (int i = 0; i < columCount; i++)
{
_dataTable.Columns.Add(reader.GetName(i));
}
if (Procedure == "GetResident" || Procedure == "GetResidentsList")
{
_dataTable.Columns.Add("Mark for archive", typeof(bool));
_dataTable.Columns["Mark for archive"].DefaultValue = false;
_dataTable.Columns.Add("Generate QR", typeof(bool));
_dataTable.Columns["Generate QR"].DefaultValue = false;
}
else if (Procedure.Contains("GetArchive"))
{
_dataTable.Columns.Add("Mark for restore", typeof(bool));
_dataTable.Columns["Mark for restore"].DefaultValue = false;
}
else if (Procedure == "GetAdmins")
{
_dataTable.Columns.Add("Mark for delete", typeof(bool));
_dataTable.Columns["Mark for delete"].DefaultValue = false;
}
while (reader.Read())
{
var currentRow = _dataTable.NewRow();
for (int i = 0; i < columCount; i++)
{
if (reader.IsDBNull(i))
{
currentRow[i] = string.Empty;
continue;
}
currentRow[i] = reader.GetString(i);
}
_dataTable.Rows.Add(currentRow);
}
}
_dbConnector.Disconnect();
return(_dataTable);
}
public override BlockWorkitem CreateBlockWorkItem(Address addrStart, Procedure proc, ProcessorState state)
{
Test_State = state;
Test_LastBlockWorkitem = base.CreateBlockWorkItem(addrStart, proc, state);
return(Test_LastBlockWorkitem);
}
