/// <summary>
/// procedure_spec :
/// PROCEDURE identifier(LEFT_PAREN parameter (COMMA parameter ) * RIGHT_PAREN)? ';'
/// ;
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override object VisitProcedure_spec([NotNull] PlSqlParser.Procedure_specContext context)
{
if (context.exception != null)
{
AppendException(context.exception);
return(null);
}
string procName = context.identifier().GetCleanedTexts().Join();
var method = new ProcedureModel()
{
Name = procName,
IsFunction = false,
// Description = "",
};
AppendFile(method, context.Start);
method.Code.SetSource(GetText(context));
var parameters = context.parameter();
foreach (var parameter in parameters)
{
var arg = (ArgumentModel)VisitParameter(parameter);
arg.Key = method.Arguments.Count().ToString();
method.Arguments.Add(arg);
}
Append(method);
return(method);
}
private string GenerateIdentifierName(Procedure procedure, ProcedureModel model)
{
if (procedure == null)
{
throw new ArgumentNullException(nameof(procedure));
}
var name = GenerateUniqueName(procedure, model);
var isValid = System.CodeDom.Compiler.CodeGenerator.IsValidLanguageIndependentIdentifier(name);
if (!isValid)
{
// File name contains invalid chars, remove them
var regex = new Regex(@"[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Nl}\p{Mn}\p{Mc}\p{Cf}\p{Pc}\p{Lm}]", RegexOptions.None, TimeSpan.FromSeconds(5));
name = regex.Replace(name, "");
// Class name doesn't begin with a letter, insert an underscore
if (!char.IsLetter(name, 0))
{
name = name.Insert(0, "_");
}
}
return(name.Replace(" ", string.Empty));
}
public async Task <IActionResult> PutProcedureModel(int id, ProcedureModel procedureModel)
{
if (id != procedureModel.ProcedureId)
{
return(BadRequest());
}
_context.Entry(procedureModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProcedureModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <ProcedureModel> > PostProcedureModel(ProcedureModel procedureModel)
{
_context.ProcedureModel.Add(procedureModel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetProcedureModel", new { id = procedureModel.ProcedureId }, procedureModel));
}
public ScaffoldedModel ScaffoldModel(ProcedureModel model, ModuleScaffolderOptions procedureScaffolderOptions, ref List <string> errors)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var result = new ScaffoldedModel();
errors = model.Errors;
foreach (var procedure in model.Procedures)
{
var name = GenerateIdentifierName(procedure, model) + "Result";
var classContent = WriteResultClass(procedure, procedureScaffolderOptions, name);
result.AdditionalFiles.Add(new ScaffoldedFile
{
Code = classContent,
Path = $"{name}.cs",
});
}
var dbContext = WriteProcedureDbContext(procedureScaffolderOptions, model);
result.ContextFile = new ScaffoldedFile
{
Code = dbContext,
Path = Path.GetFullPath(Path.Combine(procedureScaffolderOptions.ContextDir, procedureScaffolderOptions.ContextName + "Procedures.cs")),
};
return(result);
}
public async Task <IActionResult> Edit(int id, [Bind("ProcedureModelName,ProcedureModelName")] ProcedureModel procedureModel)
{
if (id != procedureModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(procedureModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProcedureModelExists(procedureModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(procedureModel));
}
void IOracleModelVisitor.VisitProcedure(ProcedureModel item)
{
if (this._filter(item))
{
_items.Add(item);
}
}
private void CreateComponent(ProcedureModel ptProcedureModel, ClinicalDocument clinicalDoc, III hl7III)
{
hl7Body = clinicalDoc.Component.AsStructuredBody;
functionalStatus = hl7Body.Component.Append();
hl7III = functionalStatus.Section.TemplateId.Append();
if (ptProcedureModel.root != null)
{
hl7III.Init(ptProcedureModel.root);
}
if (ptProcedureModel.code != null)
{
functionalStatus.Section.Code.Code = ptProcedureModel.code;
}
if (ptProcedureModel.codeSystem != null)
{
functionalStatus.Section.Code.CodeSystem = ptProcedureModel.codeSystem;
}
if (ptProcedureModel.codeSystemName != null)
{
functionalStatus.Section.Code.CodeSystemName = ptProcedureModel.codeSystemName;
}
if (ptProcedureModel.displayName != null)
{
functionalStatus.Section.Code.DisplayName = ptProcedureModel.displayName;
}
if (ptProcedureModel.title != null)
{
functionalStatus.Section.Title.Text = ptProcedureModel.title;
}
}
public ActionResult DeleteConfirmed(int id)
{
ProcedureModel procedureModel = db.ProcedureModels.Find(id);
db.ProcedureModels.Remove(procedureModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public override void AppendMissing(ArgumentModel argSource, ProcedureModel source, ProcedureModel target)
{
if (_buckets.Add(source))
{
var d = base.AppendDifference(source, false);
Append(source, d, target);
}
}
public override void AppendChange(ProcedureModel source, ProcedureModel target, string propertyName)
{
if (_buckets.Add(source))
{
var d = base.AppendDifference(source, target, propertyName);
Append(source, d, target);
}
}
private string GenerateIdentifierName(Procedure procedure, ProcedureModel model)
{
if (procedure == null)
{
throw new ArgumentNullException(nameof(procedure));
}
return(CreateIdentifier(GenerateUniqueName(procedure, model)).Item1);
}
public async Task <ActionResult <int> > Put(int id, [FromBody] ProcedureModel procedureModel)
{
if (id != procedureModel.Id)
{
return(BadRequest());
}
return(await _procedureService.Update(procedureModel));
}
public ProcedureModel Create(string connectionString)
{
var model = new ProcedureModel
{
Procedures = GetStoredProcedures(connectionString)
};
return(model);
}
public ActionResult Edit([Bind(Include = "Id,Name,Details")] ProcedureModel procedureModel)
{
if (ModelState.IsValid)
{
db.Entry(procedureModel).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(procedureModel));
}
public virtual void AppendMissing(ProcedureModel source)
{
AppendDifference(source, false);
if (generateSource)
{
string p = BuildPath(Path.Combine(this.folderForSource, source.Owner), "Procedures", source.Name);
WriteFile(p, CreateOrReplace + source.Code.GetSource());
}
}
public override List <ModelProc_11> Resolve(DbContextOracle context, Action <ModelProc_11> action)
{
List <ModelProc_11> List = new List <ModelProc_11>();
string colName = string.Empty;
var db = context.Database;
this.OracleContext = context;
HashSet <object> _h = new HashSet <object>();
if (action == null)
{
action =
t =>
{
ProcedureModel proc = null;
if (t.OBJECT_NAME.ExcludIfStartwith(t.OWNER, Models.Configurations.ExcludeKindEnum.Procedure))
{
return;
}
if (t.OBJECT_NAME == t.PROCEDURE_NAME)
{
return;
}
proc = new ProcedureModel()
{
Owner = t.OWNER,
PackageName = string.IsNullOrEmpty(t.PROCEDURE_NAME) ? string.Empty : t.OBJECT_NAME,
Name = string.IsNullOrEmpty(t.PROCEDURE_NAME) ? t.OBJECT_NAME : t.PROCEDURE_NAME,
IsFunction = false,
};
proc.Key = proc.BuildKey();
if (!db.Procedures.Contains(proc.Key))
{
db.Procedures.Add(proc);
}
}
}
;
sql = string.Format(sql, TableQueryAndCondition());
ProcDescriptor_11 view = new ProcDescriptor_11(context.Manager.ConnectionString);
using (var reader = context.Manager.ExecuteReader(CommandType.Text, sql, QueryBase.DbParams.ToArray()))
{
view.ReadAll(reader, action).ToList();
}
return(List);
}
}
public ActionResult Create([Bind(Include = "Id,Name,Details")] ProcedureModel procedureModel)
{
if (ModelState.IsValid)
{
db.ProcedureModels.Add(procedureModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(procedureModel));
}
public ProcedureModel Create(string connectionString, ProcedureModelFactoryOptions options)
{
//TODO Filter based on options later
var model = new ProcedureModel
{
Procedures = GetStoredProcedures(connectionString)
};
return(model);
}
private string GenerateUniqueName(Procedure procedure, ProcedureModel model)
{
var numberOfNames = model.Procedures.Where(p => p.Name == procedure.Name).Count();
if (numberOfNames > 1)
{
return(procedure.Name + CultureInfo.InvariantCulture.TextInfo.ToTitleCase(procedure.Schema));
}
return(procedure.Name);
}
public async Task <IActionResult> Create([Bind("ProcedureModelName,ProcedureModelName")] ProcedureModel procedureModel)
{
if (ModelState.IsValid)
{
_context.Add(procedureModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(procedureModel));
}
protected override ProcedureModel MapProcedure(DataRow row)
{
var procedure = new ProcedureModel();
procedure.RoutineCatalog = row.GetString("ROUTINE_CATALOG");
procedure.RoutineSchema = row.GetString("ROUTINE_SCHEMA");
procedure.RoutineName = row.GetString("ROUTINE_NAME");
procedure.RoutineType = row.GetString("ROUTINE_TYPE");
procedure.Created = row.GetDateTime("CREATED");
procedure.LastAltered = row.GetDateTime("LAST_ALTERED");
return(procedure);
}
// GET: Procedure/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProcedureModel procedureModel = db.ProcedureModels.Find(id);
if (procedureModel == null)
{
return(HttpNotFound());
}
return(View(procedureModel));
}
// GET: Doctor/AddProcedure
public ActionResult AddProcedure(int doctorId, string procedureName)
{
DoctorModel doctor = db.DoctorModels.Find(doctorId);
ProcedureModel procedure = db.ProcedureModels.SingleOrDefault(x => x.Name == procedureName);
DoctorsAndProceduresModel model = new DoctorsAndProceduresModel()
{
Doctor = doctor,
Procedure = procedure
};
db.DoctorsAndProceduresModel.Add(model);
db.SaveChanges();
return(RedirectToAction("Details", new { Id = doctorId }));
}
public virtual void AppendChange(ProcedureModel source, ProcedureModel target, string propertyName)
{
AppendDifference(source, target, propertyName);
if (generateSource)
{
string p = BuildPath(Path.Combine(this.folderForSource, source.Owner), "Procedures", source.Name);
WriteFile(p, CreateOrReplace + source.Code.GetSource());
}
if (generateTarget)
{
string p = BuildPath(Path.Combine(this.folderForTarget, target.Owner), "Procedures", target.Name);
WriteFile(p, CreateOrReplace + target.Code.GetSource());
}
}
private void Append(ProcedureModel source, DifferenceModel d, ProcedureModel target)
{
string p = BuildPath(Path.Combine(this.folderForTarget, source.Owner), "Procedures", source.Name);
StringBuilder sb = new StringBuilder();
if (!File.Exists(p))
{
var txt = CreateOrReplace + source.Code.GetSource().Trim();
if (!txt.EndsWith(@"\"))
{
txt = txt + Environment.NewLine + @"\";
}
sb.AppendLine(txt);
if (sb.Length > 0)
{
WriteFile(p, sb.ToString());
d.Addfile(p);
}
}
if (target != null)
{
p = BuildPath(Path.Combine(this.folderForTarget, source.Owner), "Procedures", source.Name, true);
sb = new StringBuilder();
if (!File.Exists(p))
{
var txt = CreateOrReplace + target.Code.GetSource().Trim();
if (!txt.EndsWith(@"\"))
{
txt = txt + Environment.NewLine + @"\";
}
sb.AppendLine(txt);
if (sb.Length > 0)
{
WriteFile(p, sb.ToString());
d.Addfile(p);
}
}
}
}
/// <summary>
/// function_spec :
/// FUNCTION identifier(LEFT_PAREN parameter (COMMA parameter)* RIGHT_PAREN)?
/// RETURN type_spec(DETERMINISTIC)? (RESULT_CACHE)? ';'
/// ;
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override object VisitFunction_spec([NotNull] PlSqlParser.Function_specContext context)
{
if (context.exception != null)
{
AppendException(context.exception);
return(null);
}
string funcName = context.identifier().GetCleanedTexts().Join();
var method = new ProcedureModel()
{
Name = funcName,
IsFunction = true,
// Description = "",
};
AppendFile(method, context.Start);
method.Code.SetSource(GetText(context));
var parameters = context.parameter();
foreach (var parameter in parameters)
{
var arg = (ArgumentModel)VisitParameter(parameter);
arg.Key = method.Arguments.Count().ToString();
method.Arguments.Add(arg);
}
var type_spec = context.type_spec();
var returnType = (OTypeReference)VisitType_spec(type_spec);
method.ResultType = new ProcedureResult()
{
Type = returnType
};
Append(method);
return(method);
}
public string FillPatientProcedure(ClinicalDocument clinicalDoc, Factory hl7factory, III hl7III, PatientClinicalInformation patientinfo)
{
string clinicdetais = string.Empty;
ptProcedureModel = new ProcedureModel();
CreateComponent(ptProcedureModel, clinicalDoc, hl7III);// Manage Allergy Component
//FillProcedureContent(patientinfo, hl7factory);
int i = 0;
if (patientinfo.ptAllergies.Count > 0)
{
foreach (ProcedureList item in patientinfo.ptProcedure)
{
GenerateProcedureEntry(item, (i + 1), patientinfo, hl7III, hl7factory);
}
}
else
{
GenerateProcedureEntryEmpty(hl7III, hl7factory);
}
return(clinicalDoc.Xml);
}
public override List <ModelProcWithArgument_11> Resolve(DbContextOracle context, Action <ModelProcWithArgument_11> action)
{
this.OracleContext = context;
List <ModelProcWithArgument_11> List = new List <ModelProcWithArgument_11>();
string colName = string.Empty;
var db = context.Database;
HashSet <object> _h = new HashSet <object>();
if (action == null)
{
action =
t =>
{
ProcedureModel proc = null;
if (!context.Use(t.PackageName) && !string.IsNullOrEmpty(t.Owner))
{
return;
}
if (t.ObjectName.ExcludIfStartwith(t.Owner, Models.Configurations.ExcludeKindEnum.Procedure))
{
return;
}
if (t.PackageName == t.ObjectName)
{
return;
}
string key = t.ObjectId.ToString() + ":" + t.PackageName + "::" + t.Owner + "." + t.ObjectName;
if (!db.Procedures.TryGet(key, out proc))
{
proc = new ProcedureModel()
{
Owner = t.Owner,
SubProgramId = t.subprogram_id,
PackageName = t.PackageName,
Name = t.ObjectName,
Key = key,
IsFunction = false,
};
proc.ResultType.Type.DataType.Owner = t.TypeOwner;
proc.ResultType.Type.DataType.Name = t.TypeName;
db.Procedures.Add(proc);
}
int index = proc.Arguments.Count;
colName = (!string.IsNullOrEmpty(t.ArgumentName) ? t.ArgumentName : "arg" + index.ToString());
OTypeReference _type = new OTypeReference();
if (colName != "arg0")
{
var arg = new ArgumentModel()
{
Key = (proc.Arguments.Count + 1).ToString(),
Name = colName,
In = t.In,
Out = t.Out,
Position = t.Position,
Sequence = t.Sequence,
IsValid = true, // !string.IsNullOrEmpty(t.ArgumentName)
};
_type = arg.Type;
proc.Arguments.Add(arg);
}
else
{
if (!string.IsNullOrEmpty(t.DataType))
{
var c = new ColumnModel()
{
Key = (proc.ResultType.Columns.Count + 1).ToString(),
Name = colName,
ColumnId = t.Position,
};
_type.DataType = c.Type;
proc.ResultType.Columns.Add(c);
}
}
if (_type != null)
{
_type.DataType.DataDefault = t.DataDefault != null?t.DataDefault.ToString()?.Trim() : string.Empty;
_type.DataType.DataLength = t.DataLength;
_type.DataType.DataPrecision = t.DataPrecision;
_type.DataType.Name = t.DataType;
_type.DataType.defaultLength = t.DefaultLength;
_type.DataType.DataLevel = t.Data_Level;
_type.DataType.Owner = t.TypeOwner;
_type.DataType.Name = t.TypeName;
if (_type.DataType.Name != null)
{
_type.DataType.DbType = TypeMatchExtension.ConvertToDbType(t.DataType).ToString();
if (t.DataType.StartsWith("PL/SQL"))
{
_type.DataType.IsRecord = t.DataType == "PL/SQL RECORD";
}
else if (_type.DataType.Name == "TABLE")
{
_type.DataType.IsRecord = true;
}
//TODO : Recopier le nom du type dans le path
}
}
proc.IsFunction = proc.ResultType.Columns.Count > 0 && (proc.ResultType.Columns.OfType <ColumnModel>().Count(col => col.Name == "arg0") == proc.ResultType.Columns.Count);
}
}
;
string _sql = string.Format(sql, ProcQueryWhereCondition);
ProcDescriptorWithArgument_11 view = new ProcDescriptorWithArgument_11(context.Manager.ConnectionString);
using (var reader = context.Manager.ExecuteReader(CommandType.Text, _sql, QueryBase.DbParams.ToArray()))
{
List = view.ReadAll(reader, action).ToList();
}
return(List);
}
}
private string WriteProcedureDbContext(ProcedureScaffolderOptions procedureScaffolderOptions, ProcedureModel model)
{
_sb = new IndentedStringBuilder();
_sb.AppendLine(PathHelper.Header);
_sb.AppendLine("using Microsoft.EntityFrameworkCore;");
_sb.AppendLine("using Microsoft.Data.SqlClient;");
_sb.AppendLine("using System;");
_sb.AppendLine("using System.Data;");
_sb.AppendLine("using System.Threading.Tasks;");
_sb.AppendLine($"using {procedureScaffolderOptions.ModelNamespace};");
_sb.AppendLine();
_sb.AppendLine($"namespace {procedureScaffolderOptions.ContextNamespace}");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"public partial class {procedureScaffolderOptions.ContextName}Procedures");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"private readonly {procedureScaffolderOptions.ContextName} _context;");
_sb.AppendLine();
_sb.AppendLine($"public {procedureScaffolderOptions.ContextName}Procedures({procedureScaffolderOptions.ContextName} context)");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"_context = context;");
}
_sb.AppendLine("}");
}
foreach (var procedure in model.Procedures)
{
GenerateProcedure(procedure);
}
_sb.AppendLine("}");
}
_sb.AppendLine("}");
return(_sb.ToString());
}
