public override void Reuse(IProcedure procedure)
{
if (procedure != null)
{
lock (_pool) _pool.Enqueue(procedure);
}
}
public void DisplayProcedureProperties(IProcedure proc, TreeNode tableNode)
{
if (this._currentHashCode == proc.GetHashCode())
{
return;
}
DataTable dt = new DataTable("MyData");
dt.Columns.Add("Property", stringType);
dt.Columns.Add("Value", stringType);
dt.Rows.Add(new object[] { "Name", proc.Name });
dt.Rows.Add(new object[] { "Alias", proc.Alias });
dt.Rows.Add(new object[] { "Schema", proc.Schema });
dt.Rows.Add(new object[] { "Description", proc.Description });
dt.Rows.Add(new object[] { "Type", proc.Type.ToString() });
dt.Rows.Add(new object[] { "DateCreated", proc.DateCreated.ToShortDateString() });
dt.Rows.Add(new object[] { "DateModified", proc.DateModified.ToShortDateString() });
dt.Rows.Add(new object[] { "ProcedureText", proc.ProcedureText });
this.Grid.DataSource = dt;
this.InitializeGrid();
this.Text = "IProcedure Properties";
this.lnkHELP.Text = "IProcedure Help ...";
this.helpInterface = "IProcedure";
this._currentHashCode = proc.GetHashCode();
}
public virtual SqlScript Alter(IProcedure sproc)
{
VelocityContext context = new VelocityContext();
context.Put("sproc", sproc);
return(CreateScript(templateManager.AlterSproc, context));
}
public ProcedureController(ICountry serv, IProductName prodName, IProductCode prodCode, IMarketingAuthorizNumber marketingAuthorizNumber, IPackSize packSize,
IApprDocsType apprDocsType, IStrength strength, IManufacturer manufacturer, IArtwork artwork, IMarketingAuthorizHolder marketingAuthorizHolder,
IPharmaceuticalForm pharmaceuticalForm, IProductService product, IProcedure procedure, IBaseEmailService emailService, IArchProccessor archProccessor)
{
_countryService = serv;
_productNameService = prodName;
_productCodeService = prodCode;
_packSizeService = packSize;
_marketingAuthorizNumberService = marketingAuthorizNumber;
_apprDocsTypeService = apprDocsType;
_strengthService = strength;
_manufacturerService = manufacturer;
_artworkService = artwork;
_marketingAuthorizHolderService = marketingAuthorizHolder;
_pharmaceuticalFormService = pharmaceuticalForm;
_productService = product;
_emailService = emailService;
_procedureService = procedure;
_archProccessor = archProccessor;
emailer = new Emailer()
{
Login = WebConfigurationManager.AppSettings["login"],
Pass = WebConfigurationManager.AppSettings["password"],
From = WebConfigurationManager.AppSettings["from"],
Port = int.Parse(WebConfigurationManager.AppSettings["smtpPort"]),
SmtpServer = WebConfigurationManager.AppSettings["smtpSrv"],
DirectorMail = WebConfigurationManager.AppSettings["directorMail"],
DeveloperMail = WebConfigurationManager.AppSettings["developerMail"],
};
_currentUser = GetCurrentUser();
}
public static string GenerateNameByProceduce(IProcedure procedure, string format, StringCase stringCase, string filterString)
{
string generateName = procedure.Name;
if (!string.IsNullOrEmpty(filterString))
{
string[] filterStrings = filterString.Split((",").ToCharArray());
foreach (string s in filterStrings)
{
if (generateName.ToUpper().StartsWith(s.ToUpper()))
{
generateName = generateName.Substring(s.Length, generateName.Length - s.Length);
}
}
}
switch (stringCase)
{
case StringCase.CamelCase:
generateName = utils.SetCamelCase(generateName);
break;
case StringCase.PascalCase:
generateName = utils.SetPascalCase(generateName);
break;
}
return string.Format(format, generateName);
}
public void Dispose()
{
//htWindow.Dispose();
(Content as Page_CreateRecipe).DataContext = null;
(Content as Page_CreateRecipe).Close();
Content = null;
(wireInspectVerify as WireInspectVerify).OnSaveXML -= SaveXML;
Procedures = null;
wireAddAutoRegion.Dispose();
wireAddRegion.Dispose();
wireInspectVerify.Dispose();
wireAddRegion = null;
wireInspectVerify = null;
wireObject = null;
wireParameter = null;
startBondOnRecipes = null;
endBondOnRecipes = null;
startBallAutoUserRegion = null;
stopBallAutoUserRegion = null;
wireRegionsModelGroup = null;
wireRegionsGroup = null;
}
public long ExecuteNonQuery(
IProcedure procedure,
ICommand command,
int timeoutSeconds,
SQLiteConnection connection,
SQLiteTransaction transaction)
{
if (procedure == null)
{
return(0);
}
var adoProcedure = procedure as IAdoProcedure;
if (adoProcedure != null)
{
if (timeoutSeconds == 0)
{
return(ExecuteNonQuery(adoProcedure, command, connection, transaction));
}
return(ExecuteNonQuery(adoProcedure, command, timeoutSeconds, connection, transaction));
}
var nativeProcedure = procedure as INativeProcedure;
if (nativeProcedure != null)
{
throw new NotImplementedException("Procedures that access the SQLite engine natively are not supported in this version");
}
throw new PriusException("Unknown procedure type '" + procedure.GetType().FullName + "'");
}
public string History(string type)
{
IProcedure procedure = null;
switch (type)
{
case "Chip":
procedure = chip; break;
case "Vaccinate":
procedure = vaccinate; break;
case "Fitness":
procedure = fitness; break;
case "Play":
procedure = play; break;
case "DentalCare":
procedure = dentalCare; break;
case "NailTrim":
procedure = nailTrim; break;
}
return(procedure.History());
}
public FeedAutoCompleteTask(IProcedure callback, string filter, RadAutoCompleteTextView autocomplete)
{
this.remoteCallback = callback;
this.filter = filter;
this.autocomplete = autocomplete;
this.data = new JSONArray();
}
public IniRecipe()
{
Content = new Page_CreateRecipe();
(Content as Page_CreateRecipe).DataContext = this;
htWindow = (Content as Page_CreateRecipe).htWindow;
DisplayName = "创建全局数据";
createReference = new CreateReference(htWindow,
iniObjects,
iniParameters,
IniDirectory,
DieUserRegions);
inspectNode = new InspectNode(htWindow,
iniParameters,
ModelsFile,
RecipeFile);
(createReference as CreateReference).OnSaveXML += SaveXML;
// 0118;
htWindow.useInspectNode(inspectNode as InspectNode);
Procedures = new IProcedure[]
{
createReference,
inspectNode
};
ProcedureChanged(0);
}
private void ExpandProcedure(IProcedure procedure, TreeNode node)
{
if (HasBlankNode(node))
{
TreeNode n;
if (procedure.Parameters.Count > 0)
{
n = new TreeNode("Parameters");
n.Tag = new NodeData(NodeType.PARAMETERS, procedure.Parameters);
n.SelectedImageIndex = n.SelectedImageIndex = n.ImageIndex = 17;
node.Nodes.Add(n);
n.Nodes.Add(this.BlankNode);
}
if (procedure.ResultColumns.Count > 0)
{
n = new TreeNode("ResultColumns");
n.Tag = new NodeData(NodeType.RESULTCOLUMNS, procedure.ResultColumns);
n.SelectedImageIndex = n.ImageIndex = 19;
node.Nodes.Add(n);
n.Nodes.Add(this.BlankNode);
}
}
}
public string History(string procedureType)
{
Enum.TryParse(procedureType, out ProcedureType procedureTypeEnum);
IProcedure procedure = this.procedures[procedureTypeEnum];
return(procedure.History().Trim());
}
public Result(ICaseInfo @case, IProcedure procedure, ISubjectInfo subject, IResultData data)
{
this.@case = @case;
this.procedure = procedure;
this.subject = subject;
this.data = data;
}
private string donusDegeriVarsaSetle(IProcedure proc)
{
string donusDegeri = "void";
foreach (IParameter param in proc.Parameters)
{
if (param.Direction == ParamDirection.ReturnValue)
{
donusDegeri = param.LanguageType;
donusParamVarMi = true;
donusParamAdi = param.Name;
donucParamTipi = param.LanguageType;
}
else if (param.Direction == ParamDirection.InputOutput)
{
inputOutputParams.Add(param);
}
}
if (sorguKomutuMu && sorguSonucSetiTekElemanli)
{
donusDegeri = sorguSonucuTekElemanTipi;
}
else if (sorguKomutuMu && !sorguSonucSetiTekElemanli)
{
donusDegeri = "DataTable";
}
return(donusDegeri);
}
private object LoadDescriptionMembers(PatternScanner scanner, Type type, object parent, object instance, object[] procedureConstructorParams = null)
{
Type procItfType = typeof(IProcedure);
if (parent == null)
{
instance = Activator.CreateInstance(type, procedureConstructorParams);
}
//else if (instance == null)
//{
// var constructor = type.GetConstructor(new[] { parent.GetType() });
// if (constructor != null)
// instance = constructor.Invoke(new[] { parent });
// else
// instance = Activator.CreateInstance(type);
//}
var props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (var prop in props)
{
if (procItfType.IsAssignableFrom(prop.PropertyType))
{
IProcedure proc = (IProcedure)prop.GetValue(instance);
var hintAddr = CachedAddresses.ContainsKey(proc.Pattern.PatternText)
? CachedAddresses[proc.Pattern.PatternText]
: 0;
var scanRes = scanner.Find(proc.Pattern, hintAddr);
if (scanRes.Found == false)
{
throw new ArgumentException($"Procedure {prop.DeclaringType.Name}.{prop.Name} could not be found.");
}
proc.Factory = Factory;
proc.BaseAddr = scanRes.BaseAddress;
CachedAddresses[proc.Pattern.PatternText] = scanRes.Offset;
}
else if (prop.PropertyType.GetTypeInfo().IsClass)
{
var propInstance = prop.GetValue(instance);
if (propInstance != null)
{
LoadDescriptionMembers(scanner, prop.PropertyType, instance, propInstance);
}
//if (propInstance == null)
// prop.SetValue(instance, subClassInst);
}
}
return(instance);
}
static internal IFilingTransactionProvider GetFilingTransactionProvider(IProcedure procedure)
{
Type type = ObjectFactory.GetType("Empiria.Land.Registration",
"Empiria.Land.Providers.LandFilingTransactionProvider");
return((IFilingTransactionProvider)ObjectFactory.CreateObject(type));
}
public Result(ICaseInfo @case, IProcedure procedure, ISubjectInfo subject, IResultData data)
{
this.@case = @case;
this.procedure = procedure;
this.subject = subject;
this.data = data;
}
public AroundBallRegionRecipe()
{
Content = new Page_CreateRecipe();
(Content as Page_CreateRecipe).DataContext = this;
htWindow = (Content as Page_CreateRecipe).htWindow;
DisplayName = $"AroundBond模板";
createAroundBondRegionModel = new CreateAroundBondRegionModel(htWindow,
ReferenceDirectory,
ModelsFile,
RecipeFile,
AroundBondDetectionObject,
AroundBondRegInspectParameter,
AroundBondRegUserRegions,
ModelsDirectory
);
(createAroundBondRegionModel as CreateAroundBondRegionModel).OnSaveXML += SaveXML;
// 0127
htWindow.useCreateAroundBondRegionModel(createAroundBondRegionModel as CreateAroundBondRegionModel);
Procedures = new IProcedure[]
{
createAroundBondRegionModel,
};
ProcedureChanged(0);
}
private static Function CreateSSDLFunction(IProcedure procedure)
{
Function function = new Function()
{
Name = procedure.Name,
Schema = procedure.SchemaName,
Aggregate = false,
BuiltIn = false,
NiladicFunction = false,
IsComposable = false,
ParameterTypeSemantics = ParameterTypeSemantics.AllowImplicitConversion
};
foreach (IProcedureParameter procedureParameter in procedure.Items)
{
FunctionParameter functionParameter = new FunctionParameter()
{
Name = procedureParameter.Name,
Type = procedureParameter.DataType,
Mode = (ParameterMode)procedureParameter.ParameterMode
};
function.Parameters.Add(functionParameter);
}
return(function);
}
public string History(string procedureType)
{
IProcedure procedure = null;
switch (procedureType)
{
case "Charge":
procedure = ChargeProcedure;
break;
case "Chip":
procedure = ChipProcedure;
break;
case "Polish":
procedure = PolishProcedure;
break;
case "Rest:":
procedure = RestProcedure;
break;
case "TechCheck":
procedure = TechCheckProcedure;
break;
case "Work":
procedure = WorkProcedure;
break;
}
return(procedure.History());
}
public List <ProcedureList> FillProcedure(IEntryCollection entryCollection)
{
List <ProcedureList> procedureList = new List <ProcedureList>();
foreach (IEntry entryitem in entryCollection)
{
IProcedure entryProcedure = entryitem.AsProcedure;
if (entryProcedure != null)
{
IObservation entryObservatio = entryitem.AsObservation;
ICD meterialCode;
//if (entryProcedure != null)
//{
// meterialCode = entryProcedure.Code;
//}
//else
//{
// meterialCode = entryObservatio.Code;
//}
meterialCode = entryProcedure.Code;
ProcedureList ptprocedureList = new ProcedureList();
ptprocedureList.CPTCodes = meterialCode.Code;
ptprocedureList.Description = meterialCode.DisplayName;
procedureList.Add(ptprocedureList);
}
}
return(procedureList);
}
private void generateParametersParameterBuilder(IOutput output, IProcedure proc)
{
output.autoTabLn("ParameterBuilder builder = new ParameterBuilder();");
foreach (IParameter param in proc.Parameters)
{
string yazi = "";
if ((param.Direction == ParamDirection.ReturnValue) && (!sorguKomutuMu))
{
yazi = string.Format(" builder.parameterEkleReturnValue( \"{0}\",{1});", param.Name, param.DbTargetType);
}
else if (param.Direction == ParamDirection.Input)
{
yazi = string.Format(" builder.parameterEkle( \"{0}\",{1},{0});", param.Name, param.DbTargetType);
}
else if (param.Direction == ParamDirection.Output || param.Direction == ParamDirection.InputOutput)
{
if (param.CharacterMaxLength == 0)
{
yazi = string.Format(" builder.parameterEkleOutput( \"{0}\",{1});", param.Name, param.DbTargetType);
}
else
{
yazi = string.Format(" builder.parameterEkleOutput( \"{0}\",{1},{2});", param.Name, param.DbTargetType, param.CharacterMaxLength);
}
}
output.autoTabLn(yazi);
}
}
public CutRegionRecipe()
{
Content = new Page_CreateRecipe();
(Content as Page_CreateRecipe).DataContext = this;
htWindow = (Content as Page_CreateRecipe).htWindow;
DisplayName = $"CutRegion模板";
createCutRegionModel = new CreateCutRegionModel(htWindow,
ReferenceDirectory,
ModelsFile,
RecipeFile,
CutRegionObject,
CutRegionParameter,
CutRegionUserRegions,
OriRegionUserRegions,
ModelsDirectory);
(createCutRegionModel as CreateCutRegionModel).OnSaveXML += SaveXML;
Procedures = new IProcedure[]
{
createCutRegionModel,
};
ProcedureChanged(0);
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
IMeasurementValue measurementValuesCasted = item.As <IMeasurementValue>();
if ((measurementValuesCasted != null))
{
this._parent.MeasurementValues.Add(measurementValuesCasted);
}
ITransformerObservation transformerObservationsCasted = item.As <ITransformerObservation>();
if ((transformerObservationsCasted != null))
{
this._parent.TransformerObservations.Add(transformerObservationsCasted);
}
IUserAttribute propertiesCasted = item.As <IUserAttribute>();
if ((propertiesCasted != null))
{
this._parent.Properties.Add(propertiesCasted);
}
if ((this._parent.Procedure == null))
{
IProcedure procedureCasted = item.As <IProcedure>();
if ((procedureCasted != null))
{
this._parent.Procedure = procedureCasted;
return;
}
}
}
private void generateParametersOverloadCagir(IOutput output, IProcedure proc)
{
output.autoTabLn("return " + methodName + "(");
output.increaseTab();
bool ilkVirgulsuzYazilmadi = true;
for (int i = 0; i < proc.Parameters.Count; i++)
{
IParameter param = proc.Parameters[i];
if (param.Direction == ParamDirection.ReturnValue)
{
continue;
}
if (ilkVirgulsuzYazilmadi)
{
output.autoTabLn("" + paramDirectionVeNameAl(param));
ilkVirgulsuzYazilmadi = false;
}
else
{
output.autoTabLn("," + paramDirectionVeNameAl(param));
}
}
if (parametresizMi)
{
output.autoTabLn("template");
output.autoTabLn(");");
}
else
{
output.autoTabLn(",template");
output.autoTabLn(");");
}
}
public SurfaceDetectionRecipe(int surfaceDetectionIndex)
{
this.RecipeIndex = surfaceDetectionIndex;
Content = new Page_CreateRecipe();
(Content as Page_CreateRecipe).DataContext = this;
htWindow = (Content as Page_CreateRecipe).htWindow;
DisplayName = $"表面检测{this.RecipeIndex.ToString()}模板";
surfaceDetection = new SurfaceDetection(htWindow,
SurfaceDetectionObject,
SurfaceDetectionParameter,
ReferenceDirectory,
ModelsFile,
RecipeFile,
FrameModelInspectParameter,
PegRackModelInspectParameter,
BridgeModelInspectParameter,
LoadRegionUserRegions,
ModelsDirectory);
(surfaceDetection as SurfaceDetection).OnSaveXML += SaveXML;
Procedures = new IProcedure[]
{
surfaceDetection,
};
ProcedureChanged(0);
}
//private readonly int epoxyIndex;
public EpoxyRecipe(int epoxyIndex)
{
this.RecipeIndex = epoxyIndex;
Content = new Page_CreateRecipe();
(Content as Page_CreateRecipe).DataContext = this;
htWindow = (Content as Page_CreateRecipe).htWindow;
DisplayName = $"银胶{this.RecipeIndex.ToString()}检测";
addPoxyRegions = new AddPoxyRegions(htWindow,
ModelsFile,
RecipeFile,
ReferenceDirectory,
epoxyModelObject,
epoxyParameter,
epoxyModelVerifyParameter,
epoxyModelVerifyParameterSet,
epoxyUserRegions,
ModelsDirectory,
epoxyReferceUserRegions);
(addPoxyRegions as AddPoxyRegions).OnSaveXML += SaveXML;
Procedures = new IProcedure[]
{
addPoxyRegions,
};
ProcedureChanged(0);
}
/// <summary>
/// 执行存储过程，判断是否有返回数据
/// </summary>
/// <param name="procedure">查询参数</param>
/// <returns></returns>
public bool HasRowSP(IProcedure procedure)
{
using (var connection = CreateConnection())
{
var db = GetCommandDataBase(connection);
return(db.HasRowSP(procedure.SPName, procedure.GetParameters()));
}
}
/// <summary>
/// 执行存储过程，返回第一行第一列
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="procedure">查询参数</param>
/// <returns></returns>
public T ExecuteScalarSP <T>(IProcedure procedure)
{
using (var connection = CreateConnection())
{
var db = GetCommandDataBase(connection);
return(db.ExecuteScalarSP <T>(procedure.SPName, procedure.GetParameters()));
}
}
/// <summary>
/// 执行存储过程，返回DataTable结构
/// </summary>
/// <param name="procedure"></param>
/// <param name="TableName">表名</param>
/// <returns></returns>
public DataTable GetTableSP(IProcedure procedure, string TableName)
{
using (var connection = CreateConnection())
{
var db = GetCommandDataBase(connection);
return(db.GetTableSP(procedure.SPName, TableName, procedure.GetParameters()));
}
}
public string History(string type)
{
IProcedure procedure = this.procedures.FirstOrDefault(x => x.GetType().Name == type);
string result = procedure.History(type);
return(result);
}
public IProcedurePresenter Create(IProcedure element, IProcedureView view)
{
ProcedurePresenter pres = null;
if (element != null && view != null)
{
pres = new ProcedurePresenter(element, view);
view.ProcPresenter = pres;
}
return pres;
}
public static void ImportProc(IProcedure srcProc, TableDefinitionRow destTab)
{
destTab.TableAlias = srcProc.Alias;
if (srcProc.Description.Length > 0)
destTab.TableComment = srcProc.Description;
destTab.DBTableType = "PROCEDURE"; // srcProc.Type.ToString();
destTab.OriginalName = srcProc.Name; // no guid GetOriginalName(srcProc.Guid, srcProc.Name);
ImportParameters(srcProc.Parameters, destTab);
ImportResultColumns(srcProc.ResultColumns, destTab);
}
public static void ImportProc(IProcedure srcProc, TableDefinitionDataTable destTabs)
{
System.Diagnostics.Debug.WriteLine("Import Proc " + srcProc.Name);
TableDefinitionRow destTab = destTabs.FindByTableName(srcProc.Name);
if (destTab == null)
{
destTab = destTabs.NewTableDefinitionRow();
destTab.TableName = srcProc.Name;
destTabs.AddTableDefinitionRow(destTab);
}
ImportProc(srcProc, destTab);
}
public IResultData Execute(ICase @case, IProcedure procedure, ISubject subject, ITimes times)
{
return @case.Execute(procedure, subject, times);
}
public ProcedurePresenter( IProcedure element,IProcedureView view)
{
throw new NotImplementedException();
}
public void DisplayProcedureProperties(IProcedure proc, TreeNode tableNode)
{
if (this._currentHashCode == proc.GetHashCode()) return;
propGrid.SelectedObject = proc;
this._currentHashCode = proc.GetHashCode();
}
//internal void UnpersistSimpleElement(ISimpleElement element, System.Xml.XmlReader reader)
//{
// ElUnpersister.UnpersistElement(reader);
// IElementTicket ticket = ElUnpersister.GetTicket();
// _ElementTickets.Add(ticket.ElementId, ticket);
// ElUnpersister.Reset();
//}
//internal void UnpersistCompoundElement(ICompoundElement element, System.Xml.XmlReader reader)
//{
// CompoundElUnpersister.UnpersistCompoundElement(reader);
// IElementTicket ticket = CompoundElUnpersister.GetTicket();
// _ElementTickets.Add(ticket.ElementId, ticket);
// CompoundElUnpersister.Reset();
//}
internal void UnpersistProcedure(IProcedure proc, System.Xml.XmlReader reader)
{
throw new NotImplementedException();
}
private static Function CreateSSDLFunction(IProcedure procedure)
{
Function function = new Function()
{
Name = procedure.Name,
Schema = procedure.SchemaName,
Aggregate = false,
BuiltIn = false,
NiladicFunction = false,
IsComposable = false,
ParameterTypeSemantics = ParameterTypeSemantics.AllowImplicitConversion
};
foreach (IProcedureParameter procedureParameter in procedure.Items)
{
FunctionParameter functionParameter = new FunctionParameter()
{
Name = procedureParameter.Name,
Type = procedureParameter.DataType,
Mode = (ParameterMode)procedureParameter.ParameterMode
};
function.Parameters.Add(functionParameter);
}
return function;
}
public void AddProcedure(IProcedure procedure)
{
this.procedures.Add(procedure);
}
public void DisplayProcedureProperties(IProcedure proc, TreeNode tableNode)
{
DataTable dt = new DataTable("MyData");
dt.Columns.Add("Property", stringType);
dt.Columns.Add("Value", stringType);
dt.Rows.Add(new object[] {"Name", proc.Name});
dt.Rows.Add(new object[] {"Alias", proc.Alias});
dt.Rows.Add(new object[] {"Schema", proc.Schema});
dt.Rows.Add(new object[] {"Description", proc.Description});
dt.Rows.Add(new object[] {"Type", proc.Type.ToString()});
dt.Rows.Add(new object[] {"DateCreated", proc.DateCreated.ToShortDateString()});
dt.Rows.Add(new object[] {"DateModified", proc.DateModified.ToShortDateString()});
dt.Rows.Add(new object[] {"ProcedureText", proc.ProcedureText});
this.Grid.DataSource = dt;
this.InitializeGrid();
this.Text = "IProcedure Properties";
this.lnkHELP.Text = "IProcedure Help ...";
this.helpInterface = "IProcedure";
}
public Instance(ICase @case, ISubject subject, IProcedure procedure)
{
this.@case = @case;
this.subject = subject;
this.procedure = procedure;
}
internal IProcOptionsMgr _CreateOptionsMgr(IProcedure proc)
{
IProcOptionsMgr mgr = null;
if (proc != null)
{
mgr = new ProcedureOptionsMgr();
}
return mgr;
}
public KeyValueCollection ExtendedProperties(IProcedure proc)
{
return ExtendedProperties(proc.Database, proc.Schema, "procedure", proc.Name, null);
}
internal IProcSettingsMgr _CreateSettingsMgr(IProcedure proc)
{
IProcSettingsMgr mgr = null;
if (proc != null)
{
mgr = new ProcedureSettingsMgr();
}
return mgr;
}
public IProcSettingsMgr CreateSettingsMgr(IProcedure proc)
{
return _CreateSettingsMgr( proc);
}
internal void PersistProcedure(IProcedure proc, System.Xml.XmlWriter writer)
{
throw new NotImplementedException();
}
private void ExpandProcedure(IProcedure procedure, TreeNode node)
{
if(HasBlankNode(node))
{
TreeNode n;
if(procedure.Parameters.Count > 0)
{
n = new TreeNode("Parameters");
n.Tag = new NodeData(NodeType.PARAMETERS, procedure.Parameters);
n.SelectedImageIndex = n.SelectedImageIndex = n.ImageIndex = 17;
node.Nodes.Add(n);
n.Nodes.Add(this.BlankNode);
}
if(procedure.ResultColumns.Count > 0)
{
n = new TreeNode("ResultColumns");
n.Tag = new NodeData(NodeType.RESULTCOLUMNS, procedure.ResultColumns);
n.SelectedImageIndex = n.ImageIndex = 19;
node.Nodes.Add(n);
n.Nodes.Add(this.BlankNode);
}
}
}
SqlParameterCollection CreateSqlParameters(IProcedure procedure)
{
SqlParameterCollection col = new SqlParameterCollection();
SqlParameter par = null;
foreach (var element in procedure.Items) {
DbType dbType = TypeHelpers.DbTypeFromStringRepresenation(element.DataType);
par = new SqlParameter(element.Name,dbType,"",ParameterDirection.Input);
if (element.ParameterMode == ParameterMode.In) {
par.ParameterDirection = ParameterDirection.Input;
} else if (element.ParameterMode == ParameterMode. InOut){
par.ParameterDirection = ParameterDirection.InputOutput;
}
col.Add(par);
}
return col;
}
public IProcOptionsMgr CreateOptionsMgr(IProcedure proc)
{
return _CreateOptionsMgr(proc);
}
