public virtual T Build(TKey kSym, DBConnectionPool connection, BlaCommonStorage bcs)
{
var local = (T)Activator.CreateInstance(_items[kSym]);
local.Setup(connection, bcs);
return(local);
}
public BlaDBVariantDefinition(DBConnectionPool conn, BlaRequest req)
{
Year = req.Slice.Year;
iModel = req.Slice.Model;
var com = new SqlCommand(
"select LX3050, LX418C, LX428C, LX468P, LX418P, LX428P, LX468K, LX118R, LX338V, Nazwa from [mgm].[F7210_H02_VarRecord] (@Project, @Year, @Model" +
(req.Slice.Variant != null ? ", @Variant" : ", null") + ")", conn.Connection);
com.Parameters.AddWithValue("@Project", req.Slice.ProjectID);
com.Parameters.AddWithValue("@Year", req.Slice.Year);
com.Parameters.AddWithValue("@Model", req.Slice.Model);
if (req.Slice.Variant != null)
{
var spa = com.Parameters.AddWithValue("@Variant", req.Slice.Variant);
spa.DbType = DbType.Int32;
}
var r = com.ExecuteReader();
if (!r.Read())
{
throw new ArgumentException("Nie można odczytać tabeli wariantów");
}
iLX3050 = r.GetInt32(0);
iLX418C = r.GetInt32(1);
iLX428C = r.GetInt32(2);
iLX468P = r.GetInt32(3);
iLX418P = r.GetInt32(4);
iLX428P = r.GetInt32(5);
iLX468K = r.GetInt32(6);
iLX118R = r.GetInt32(7);
iLX338V = r.GetInt32(8);
Nazwa = r.IsDBNull(9) ? "" : r.GetString(9);
}
//public GrWAtt_Values AttValues = new GrWAtt_Values();
public BlaCommonStorage(DBConnectionPool pool, BlaRequest request = null)
{
Attributies = new GrWAttributies();
//WorkMode = workMode;
Request = request;
EntityReader = new JohEntityReader(pool);
PuT = new PuTModel(this);
}
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="bind">Połączenie do bazy danych</param>
/// <param name="procID">ID funkcji/procedury z tabeli [7125]</param>
/// <param name="procName">Nazwa funkcji (ze schemą)</param>
/// <param name="objIDField">Nazwa pola zawierająca dane ObjectID</param>
/// <param name="attsrcs">Wyliczenie źródeł atrybutów</param>
/// <param name="pargtempl">ID szablonu argumentów funkcji</param>
public GruFuncOrStoredProcReader(DBConnectionPool bind, int procID, string procName, string objIDField,
int pargtempl, IEnumerable <GrWAtt_VSource> attsrcs)
{
__bind = bind;
__attsources = attsrcs.ToList();
__commandText =
$"select {string.Join(", ", __attsources.SelectMany(w => w.Fields().Distinct().OrderBy(r => r)))}, {objIDField} from {procName}({_.I.GrunaTemplater.BracketContent(pargtempl)})";
__procArgTmpl = pargtempl;
__objIDField = objIDField;
}
private static void __SetupConnection(byte?connID = null)
{
__db = I.Cfg.ConnectionPool(connID);
//__db = new DBConnectionPool()
//{
// Server = I.Cfg.Entry["serverName"],
// Database = I.Cfg.Entry["database"]
//};
}
public void disposeAllConn()
{
try
{
DBConnectionPool.disposeAllConn();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public GrWAtt_Value GetValue(int objectID, IDataRecord rec)
{
if (__valueFieldIndex < 0)
{
var t = DBConnectionPool.FieldIndices(Fields(), rec).ToArray();
__valueFieldIndex = t[0];
if (t.Length > 1)
{
__optionalSubAttFieldIndex = t[1];
}
}
//if (__valueFieldType == typeof(DBNull))
//{
// __valueFieldType = rec.GetFieldType(__valueFieldIndex);
//}
if (rec.IsDBNull(__valueFieldIndex))
{
return(null);
}
GrWAtt_Value pva = null;
switch (DataType)
{
case BlaVisumDataType.Integer:
case BlaVisumDataType.Area:
case BlaVisumDataType.Decimal:
case BlaVisumDataType.Double:
case BlaVisumDataType.Length:
case BlaVisumDataType.Precise_time:
case BlaVisumDataType.Time_period:
case BlaVisumDataType.Velocity:
var ivs = new PhaNumericAttribValue();
__QuickSetupAttValue(objectID, rec, ivs);
var va = rec.GetValue(__valueFieldIndex);
var c = va.GetType();
ivs.Value = Convert.ToDecimal(va);
pva = ivs;
break;
case BlaVisumDataType.String:
var nvs = new PhaStringAttribValue();
__QuickSetupAttValue(objectID, rec, nvs);
nvs.Value = rec.GetString(__valueFieldIndex);
pva = nvs;
break;
default:
throw new InvalidExpressionException();
}
return(pva);
}
public override bool Load(DBConnectionPool pool, BlaCommonStorage bls)
{
var b = true;
var a = 0;
try
{
_kitems.AddRange(bls.EntityReader[41].Query(pool, bls.Variant)
.Select(m => new Mode_PrT(m, bls.DemFoundation.TSysList)));
bls.Reporter.AddMessage(new RoReMessage
{
Caller = "ModesList – PrT", EvType = RoReEventType.Info,
Message = $"Ilość gałęzi transportu: {_kitems.Count - a}"
});
a += _kitems.Count;
}
catch (Exception e)
{
b = false;
bls.Reporter.AddException(e, "ModesList – PrT");
}
try
{
if (b)
{
_kitems.AddRange(bls.EntityReader[42].Query(pool, bls.Variant).GroupBy(t => t.GetIntNumber(0))
.Select(m => new Mode_PuT(m, bls.DemFoundation.TSysList)));
}
bls.Reporter.AddMessage(new RoReMessage
{
Caller = "ModesList – PuT", EvType = RoReEventType.Info,
Message = $"Ilość gałęzi transportu: {_kitems.Count - a}"
});
a += _kitems.Count;
}
catch (Exception e)
{
b = false;
bls.Reporter.AddException(e, "ModesList – PuT");
}
return(b);
}
protected bool _Load(DBConnectionPool pool, BlaCommonStorage platform, int johQueryIndex)
{
var b = true;
try
{
_kitems.AddRange(platform.EntityReader[johQueryIndex].Query(pool, platform.Variant)
.Select(d => _KarObjCreation(d)));
platform.Reporter.AddMessage(new RoReMessage
{
Caller = GetType().Name, EvType = RoReEventType.Info, Message = $"Ilość elementów: {_kitems.Count}"
});
}
catch (Exception e)
{
b = false;
platform.Reporter.AddException(e, GetType().Name);
}
return(b);
}
public TSysList(DBConnectionPool pool, BlaCommonStorage bls)
{
//var tsyses = pool.ExecuteQuery(__QUERY, new SqlParameter[] { new SqlParameter("@demSlice", bls.Variant.iLX3050) });
var tsyses = bls.EntityReader[3].Query(pool, bls.Variant);
__itslist = tsyses.Select(r =>
{
switch (r.GetByte(3))
{
case 0:
case 1:
case 2:
return(new TSys(r));
case 100:
return(new PrTTSys(r));
default:
throw new BlaEUnexpectedValue("Nieznany typ TSys");
}
}).ToList();
}
public override bool Load(DBConnectionPool pool, BlaCommonStorage platform)
{
var b = true;
try
{
_kitems.AddRange(platform.EntityReader[50].Query(pool, platform.Variant)
.Select(d => new DSeg(d, platform.DemFoundation.Modes)));
platform.Reporter.AddMessage(new RoReMessage
{
Caller = "Demand Segments", EvType = RoReEventType.Info,
Message = $"Ilość segmentów popytu: {_kitems.Count}"
});
}
catch (Exception e)
{
b = false;
platform.Reporter.AddException(e, "Demand Segments");
}
return(b);
}
/// <summary>
/// Odpytuje funkcję wydając wyniki w postaci wyliczenia GrWAtt_Value
/// </summary>
/// <returns></returns>
public IEnumerable <GrWAtt_Value> Ask(BlaDBVariantDefinition var)
{
var objIDindex = -1;
foreach (var row in __bind.ExecuteQuery(__commandText, _.I.GrunaTemplater.PrepareCmd(__procArgTmpl, var)))
{
if (objIDindex < 0)
{
objIDindex = DBConnectionPool.FieldIndices(new[] { __objIDField }, row).First();
}
var objID = row.GetIntNumber(objIDindex);
foreach (var att in __attsources)
{
var a = att.GetValue(objID, row);
if (a != null)
{
yield return(a);
}
}
}
//yield break;
}
public bool Load(DBConnectionPool cpool)
{
var b = true;
try
{
__root.Reporter.AddInfo("Odczyt definicji przystanków");
var hsdef = __root.EntityReader[401].Query(cpool, __root.Variant)
.Select(r => new
{
lx4010 = r.GetIntNumber(0), lx4060 = r.GetIntNumber(1), Nazwa = r.GetString(2),
LX4002 = r.GetIntNumber(3)
}).Join(__root.Graph.Nodes.Items, h => h.lx4010, no => no.ObjectId,
(h, no) => new { node = no, h.lx4010, h.Nazwa, h.lx4060, h.LX4002 })
.ToUniqueList(kT => kT.lx4010);
__root.Reporter.AddInfo("Odczyt TSys dla przystanków");
var hstsys = __root.EntityReader[402].Query(cpool, __root.Variant)
.Select(r => new { lx4010 = r.GetIntNumber(0), lx3121 = r.GetIntNumber(1) }).Join(
__root.DemFoundation.TSysList.PuT(), h => h.lx3121, pu => pu.ID,
(h, pu) => new { h.lx4010, tsys = pu });
var hs = hsdef.GroupJoin(hstsys, d => d.lx4010, h => h.lx4010, (d, hmany) => new { d, hmany }).ToList();
foreach (var h in hs)
{
var st = new MckStop(h.d.node);
st.Name = h.d.Nazwa;
st.TypeNo = h.d.lx4060;
st.HaltOfTSys = new TSysSet(h.hmany.Select(t => t.tsys));
}
}
catch (Exception e)
{
__root.Reporter.AddException(e);
b = false;
}
return(b);
}
public static IEnumerable <GrWAtt_Value> Parse(/*byte EntityID,*/ DBConnectionPool connection,
IEnumerable <GrWAtt_Definition> defs, BlaDBVariantDefinition var, RoReporter reporter = null)
{
var attids = defs.Select(a => a.AttID).Distinct().ToArray();
if (attids.Length < 1)
{
return(Enumerable.Empty <GrWAtt_Value>());
}
var zahada = string.Join(", ", attids);
var cmd = new SqlCommand(string.Format(SQLCOMMAND_ATT, zahada), connection.Connection);
var re = cmd.ExecuteReader();
reporter?.AddInfo("Odczyt definicji funkcji wydających atrybuty");
var rer = re.Cast <IDataRecord>();
var fields = rer.Select(r => new
{
id = r["LX7110"], proc = string.Format("[{0}].[{1}]", r["Schema"], r["NazwaFunkcji"]),
procid = (int)r["LX7125"], pargtempl = (int)r["LX7121"], objectid = (string)r["ObjectID_NazwaPola"],
attsrc = new GrWAtt_VSource(r)
}).ToList();
rer = null;
re = null;
var fieldsByProcs = fields.GroupBy(q => q.procid).Select(q =>
{
var pro = q.First();
reporter?.AddInfo($"Odczyt funkcji {pro.proc} ({pro.procid})");
return(new GruFuncOrStoredProcReader(connection, pro.procid, objIDField: pro.objectid,
pargtempl: pro.pargtempl, procName: pro.proc, attsrcs: q.Select(w => w.attsrc)));
});
return(fieldsByProcs.SelectMany(t => t.Ask(var)));
//return Enumerable.Empty<GrWAtt_Value>();
}
/// <summary>
/// Depreciated
/// </summary>
/// <param name="project"></param>
/// <param name="year"></param>
/// <param name="variant"></param>
/// <param name="model"></param>
/// <param name="connection"></param>
/// <param name="reporter"></param>
/// <param name="workMode"></param>
public void InitializeBatch(int project, decimal year, int?variant, int model, DBConnectionPool connection,
RoReporter reporter, Blasewitz.Bla_WorkMode workMode)
{
throw new NotImplementedException("Funkcja zdeprecjonowana");
//__storage = new BlaCommonStorage(workMode)
//{
// Variant = new BlaDBVariantDefinition(connection, project, variant, year, model),
// Reporter = reporter
//};
}
public override bool Load(DBConnectionPool pool, BlaCommonStorage bls)
{
return(_Load(pool, bls, 100));
}
public virtual void Setup(DBConnectionPool connection, BlaCommonStorage phs)
{
_connection = connection;
_phs = phs;
}
public SqlDataReader Reader(DBConnectionPool pool, BlaDBVariantDefinition variantDef)
{
return(pool.ExecuteReader(
__GrunaCommand(),
_.I.GrunaTemplater.PrepareCmd(__lx7121_ArgTmpl, variantDef)));
}
public IEnumerable <IDataRecord> Query(DBConnectionPool pool, BlaDBVariantDefinition variantDef)
{
return(pool.ExecuteQuery(
__GrunaCommand(),
_.I.GrunaTemplater.PrepareCmd(__lx7121_ArgTmpl, variantDef)));
}
internal static void Initialize(DBConnectionPool systemDB)
{
DBHelper.UpdateTableSchema <CatalogConstructionUpdater>(systemDB);
}
public JohEntityReader(DBConnectionPool conn)
{
__entities = conn.ExecuteQuery(__QUERY).Select(j => new JohEntity(j)).ToList();
}
public virtual void Setup(DBConnectionPool connection, BlaCommonStorage phs)
{
_cpool = connection;
_platform = phs;
}
public abstract bool Load(DBConnectionPool pool, BlaCommonStorage bls);
public override IProhlisArbeitnehmer Build(byte kSym, DBConnectionPool connection, BlaCommonStorage bcs)
{
Local = base.Build(kSym, connection, bcs);
return(Local);
}
/// <summary>
/// Zwraca obiekt tłumaczący TRA
/// </summary>
/// <param name="PhA_ID">ID klasy obiektu tłumaczącego</param>
/// <param name="connection">Połączenie do bazy danych</param>
/// <returns>Obiekt tłumaczący TRA</returns>
public IProhlisArbeitnehmer Build(byte PhA_ID, DBConnectionPool connection = null)
{
return(Build(PhA_ID, connection, Storage));
}
