public Result DeleteRoutingPlanDetail(RoutingPlanDetailDto pRoutingPlanDetail)
{
var _result = new Result(true, string.Empty);
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pRoutingPlanDetail)) {
try {
var _wholesaleRouteCount = CustomerRouteManager.GetCount(_db, pRoutingPlanDetail.BaseRouteId);
if (_wholesaleRouteCount > 0)
{
throw new Exception("Cannot delete Routing Plan Route, it's used in one or more Wholesale Dial Plans");
}
var _retailRouteCount = 0; //TODO: X_Controller.GetRetailRouteCount(_db, pRoutingPlanDetail.BaseRouteId);
if (_retailRouteCount > 0)
{
throw new Exception("Cannot delete Routing Plan Route, it's used in one or more Retail Dial Plans");
}
RoutingManager.DeleteRoutingPlanDetail(_db, pRoutingPlanDetail);
_tx.Commit();
}
catch (Exception _ex) {
_result.Success = false;
_result.ErrorMessage = _ex.Message;
TimokLogger.Instance.LogRbr(LogSeverity.Critical, "RoutingController.DeleteRoutingPlanDetail", string.Format("Exception:\r\n{0}", _ex));
}
}
}
return(_result);
}
public TestNode(RoutingManager routingManager, TcpConnectionManager connectionManager, DataManager dataManager, EncryptionManager encryptionManager)
{
this.routingManager = routingManager;
this.connectionManager = connectionManager;
this.dataManager = dataManager;
this.encryptionManager = encryptionManager;
}
/// <summary>
/// Use this for initialization
/// </summary>
void Start()
{
// Make sure the applications continues to run in the background
Application.runInBackground = true;
// ------------------------------
// Creating a Simple REST server
// ------------------------------
// 1. Create the routing table
// HTTP Type - URL routing path with variables - Class and method to be called
// HTTP Type - /foo/bar/{variable} - DelegetorClass.MethodToBeCalled
RoutingManager routingManager = new RoutingManager();
routingManager.AddRoute(new Route(Route.Type.GET, "/color/{objname}", "MaterialInvoke.GetColor"));
routingManager.AddRoute(new Route(Route.Type.POST, "/color/{objname}", "MaterialInvoke.SetColor"));
routingManager.AddRoute(new Route(Route.Type.DELETE, "/color/{objname}", "MaterialInvoke.DeleteColor"));
// Starts the Simple REST Server
// With or without basic authorisation flag
if (!username.Equals("") && !password.Equals(""))
{
RESTfulHTTPServer.src.controller.Logger.Log(TAG, "Create basic auth");
BasicAuth basicAuth = new BasicAuth(username, password);
new SimpleRESTServer(port, routingManager, basicAuth);
}
else
{
new SimpleRESTServer(port, routingManager);
}
}
public BluemeshNode(RoutingManager routingManager, TcpConnectionManager connectionManager, DataManager dataManager, EncryptionManager encryptionManager, bool doLogMap)
{
this.RoutingManager = routingManager;
this.ConnectionManager = connectionManager;
this.DataManager = dataManager;
this.EncryptionManager = encryptionManager;
this.DoLogMap = doLogMap;
}
public void DeleteRoutingPlan(RoutingPlanDto pRoutingPlan)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pRoutingPlan)) {
RoutingManager.DeleteRoutingPlan(_db, pRoutingPlan);
_tx.Commit();
}
}
}
public void AddRoutingPlanDetails(RoutingPlanDto pRoutingPlan, int[] pSelectedBaseRouteIds, RoutingAlgorithmType pDefaultRoutingAlgorithmType)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pRoutingPlan, pSelectedBaseRouteIds, pDefaultRoutingAlgorithmType)) {
RoutingManager.AddRoutingPlanDetails(_db, pRoutingPlan, pSelectedBaseRouteIds, pDefaultRoutingAlgorithmType);
_tx.Commit();
}
}
}
public void UpdateRoutingPlanDetail(RoutingPlanDetailDto pRoutingPlanDetail)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pRoutingPlanDetail)) {
RoutingManager.UpdateRoutingPlanDetail(_db, pRoutingPlanDetail);
_tx.Commit();
}
}
}
public void DeleteBaseRoute(BaseRouteDto pBaseRoute)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pBaseRoute)) {
RoutingManager.DeleteBaseRoute(_db, pBaseRoute);
_tx.Commit();
}
}
}
private static HackerNode CreateNode(IConnectionConfig connectionConfig, IRoutingConfig routingConfig, string storagePath)
{
var encryptionManager = new EncryptionManager(((TcpAddress)connectionConfig.LocalAddress).Endpoint, connectionConfig.KeySendCooldown);
var connectionManager = new TcpConnectionManager(connectionConfig, routingConfig, encryptionManager);
var routingManager = new RoutingManager(connectionManager, routingConfig);
var dataManager = new DataManager(LoadStorage(storagePath) ?? new DataStorage(), storagePath, routingManager, encryptionManager);
return(new HackerNode(routingManager, connectionManager, dataManager, encryptionManager, routingConfig.DoLogMap));
}
//---------------------- TerminationChoice
public RoutingTableDto AddTerminationChoice(int pRoutingPlanId, int pRouteId, int pCarrierRouteId)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pRoutingPlanId, pRouteId, pCarrierRouteId)) {
RoutingManager.AddTerminationChoice(_db, pRoutingPlanId, pRouteId, pCarrierRouteId);
_tx.Commit();
}
}
return(GetRoutingTable(pRoutingPlanId, pRouteId));
}
public RoutingTableDto DeleteTerminationChoice(TerminationChoiceDto pTerminationChoice)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pTerminationChoice)) {
RoutingManager.DeleteTerminationChoice(_db, pTerminationChoice);
_tx.Commit();
}
}
return(GetRoutingTable(pTerminationChoice.RoutingPlanId, pTerminationChoice.RouteId));
}
public RoutingTableDto UpdateTerminationChoices(int pRoutingPlanId, int pRouteId, TerminationChoiceDto[] pTerminationChoices)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pRoutingPlanId, pRouteId, pTerminationChoices)) {
RoutingManager.UpdateTerminationChoices(_db, pTerminationChoices);
_tx.Commit();
}
}
return(GetRoutingTable(pRoutingPlanId, pRouteId));
}
public void AddRoutingPlan(RoutingPlanDto pRoutingPlan, int[] pSelectedBaseRouteIds, RoutingAlgorithmType pDefaultRoutingAlgorithmType)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pRoutingPlan, pSelectedBaseRouteIds, pDefaultRoutingAlgorithmType)) {
//TODO: NEW DAL - VirtualSwitch
pRoutingPlan.VirtualSwitchId = AppConstants.DefaultVirtualSwitchId;
pRoutingPlan.RoutingPlanId = RoutingManager.AddRoutingPlan(_db, pRoutingPlan);
RoutingManager.AddRoutingPlanDetails(_db, pRoutingPlan, pSelectedBaseRouteIds, pDefaultRoutingAlgorithmType);
_tx.Commit();
}
}
}
public void CloneRoutingPlan(RoutingPlanDto pNewRoutingPlan, RoutingPlanDto pRoutingPlanToClone)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pNewRoutingPlan, pRoutingPlanToClone)) {
//TODO: NEW DAL - VirtualSwitch
pNewRoutingPlan.VirtualSwitchId = AppConstants.DefaultVirtualSwitchId;
pNewRoutingPlan.RoutingPlanId = RoutingManager.AddRoutingPlan(_db, pNewRoutingPlan);
RoutingManager.CloneRoutingPlanDetails(_db, pNewRoutingPlan, pRoutingPlanToClone);
_tx.Commit();
}
}
}
//public static void AddDialCodes(DialCodeDto[] pDialCodes) {
// using (var _db = new Rbr_Db()) {
// using (var _tx = new Transaction(_db, pDialCodes)) {
// foreach (DialCodeDto _dialCode in pDialCodes) {
// CallingPlanManager.AddDialCode(_db, _dialCode);
// }
// _tx.Commit();
// }
// }
//}
public static void MoveDialCodes(DialCodeDto[] pDialCodes, BaseRouteDto pFromRoute, BaseRouteDto pToRoute)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pDialCodes, pFromRoute, pToRoute)) {
//NOTE: not used? RouteRow _fromRouteRow = RoutingManager.MapToRouteRow(pFromRoute);
RouteRow _toRouteRow = RoutingManager.MapToRouteRow(pToRoute);
foreach (DialCodeDto _dialCode in pDialCodes)
{
CallingPlanManager.MoveDialCode(_db, _dialCode, _toRouteRow);
}
_tx.Commit();
}
}
}
private void AdminLogon()
{
int key;
string password;
try
{
key = 1;
password = "******";
managerObj.Logon(key, password);
CheckForIllegalCrossThreadCalls = false;
processor = new Processor(AgentsListFromServer, listViewAgentsList, AgentsTimer);
processor.callDetailGridEvent += new CallDetailGridHandler(AddInCallDetailGrid);
processor.callDetailGridUpdateEvent += new CallDetailGridUpdater(UpdateCallDetailGrid);
mediaObj = (MediaManager)managerObj.HireMediaManager(enEventModes.EventMode_FireEvents);
routingObj = managerObj.HireRoutingManager(enEventModes.EventMode_FireEvents);
mediaObj.ListenForEvents(enMediaEventTypes.MediaEventType_AgentStatusEvents);
mediaObj.ListenForEvents(enMediaEventTypes.MediaEventType_VoiceEvents);
mediaObj.ListenForEvents(enMediaEventTypes.MediaEventType_VoiceDetailsUpdates);
mediaObj.EventOccurred += processor.EnqueueEventQueue;
//mediaObj.EventOccurred += processor.ProcessMediaEvent;
routingObj.ListenForEvents(enRoutingEventTypes.RoutingEventType_VoiceEvents);
routingObj.EventOccurred += processor.EnqueueEventQueue;
// routingObj.EventOccurred += processor.ProcessRoutingEvent;
//adminMngrObj.ListenForEvents(enAdministrationEventTypes.AdministrationEventType_AdministrationDatabaseUpdates);
//adminMngrObj.ListenForEvents(enAdministrationEventTypes.AdministrationEventType_ConfigurationSynchronizationEvents);
//adminMngrObj.EventOccurred += _objAdmin_EventOccurred;
statsManager = (StatisticsManager)managerObj.HireStatisticsManager(enEventModes.EventMode_FireEvents);
statsManager.EventOccurred += new _IStatisticsManagerEvents_EventOccurredEventHandler(processor.ProcessStatsEvent);
WriteMessage("Admin Looged on Successfuly");
FillUsersList();
}
catch (Exception ex)
{
_logger.Error("Error in AdminLogon " + ex);
}
}
private static TestNode CreateNode(IRoutingConfig routingConfig, List <IAddress> nodes, int id)
{
var connectionConfig = Substitute.For <IConnectionConfig>();
var address = new TcpAddress(new IPEndPoint(IPAddress.Loopback, 16800 + id));
connectionConfig.LocalAddress.Returns(address);
connectionConfig.PreconfiguredNodes.Returns(_ => nodes.Where(n => !Equals(n, address)).ToList());
nodes.Add(address);
connectionConfig.ConnectingSocketMaxTTL.Returns(TimeSpan.FromMilliseconds(50));
connectionConfig.ConnectingSocketsToConnectionsMultiplier.Returns(5);
connectionConfig.KeySendCooldown.Returns(TimeSpan.FromMilliseconds(1000));
var encryptionManager = new EncryptionManager(address.Endpoint, connectionConfig.KeySendCooldown);
var connectionManager = new TcpConnectionManager(connectionConfig, routingConfig, encryptionManager);
var routingManager = new RoutingManager(connectionManager, routingConfig);
var dataManager = new DataManager(new DataStorage(), "local", routingManager, encryptionManager);
return(new TestNode(routingManager, connectionManager, dataManager, encryptionManager));
}
protected virtual void Tick()
{
ConnectionManager.PurgeDeadConnections();
var selectResult = ConnectionManager.Select();
RoutingManager.UpdateConnections();
EncryptionManager.RetrievePeerKeys(ConnectionManager.EstablishedConnections.Select(c => c.RemoteAddress));
foreach (var connection in selectResult.ReadableConnections.Where(c => c.State == ConnectionState.Connected))
{
for (int i = 0; i < 2 && connection.Socket.Available > 0; i++)
{
var message = connection.Receive();
if (!RoutingManager.ProcessMessage(message, connection))
{
DataManager.ProcessMessage(message, connection);
}
}
}
RoutingManager.PushMaps(selectResult.WritableConnections.Where(c => c.State == ConnectionState.Connected));
DataManager.PushMessages(selectResult.WritableConnections.Where(c => c.State == ConnectionState.Connected));
RoutingManager.DisconnectExcessLinks();
RoutingManager.ConnectNewLinks();
foreach (var connection in selectResult.ReadableConnections)
{
//Console.WriteLine("[{0}] tick: {1} -> {2}", connectionManager.Address, connectionManager.Address, connection.RemoteAddress);
connection.Tick(true);
}
foreach (var connection in selectResult.WritableConnections)
{
//Console.WriteLine("[{0}] tick: {1} -> {2}", connectionManager.Address, connectionManager.Address, connection.RemoteAddress);
connection.Tick(false);
}
if (DoLogMap)
{
Console.WriteLine("[{0}] v: {2} {1}", RoutingManager.Map.OwnAddress, RoutingManager.Map, RoutingManager.Map.Version);
}
//if (DataManager.DataStorage.ToString().Length > 0)
// Console.WriteLine("[{0}] !! my flags : {1}", RoutingManager.Map.OwnAddress, DataManager.DataStorage);
Map = RoutingManager.Map.Links.ToList();
}
protected int getRouteId(Rbr_Db pDb, int pCountryId, RouteRecord pRouteRecord)
{
RouteRow _routeRow = RoutingManager.GetByName(pDb, args.CallingPlanId, pRouteRecord.FullName);
if (_routeRow == null)
{
_routeRow = new RouteRow();
_routeRow.Name = pRouteRecord.FullName;
_routeRow.Country_id = pCountryId;
_routeRow.Calling_plan_id = args.CallingPlanId;
_routeRow.RouteStatus = Status.Active;
RoutingManager.AddBaseRoute(pDb, RoutingManager.MapToBaseRoute(pDb, _routeRow));
}
else
{
// Existing RouteRow: delete all dialcodes
pDb.DialCodeCollection.DeleteByRoute_id(_routeRow.Route_id);
}
return(_routeRow.Route_id);
}
void importRouteRates(RouteRecord pRouteRecord) //}, int pCallingPlanId, short pId, RouteType pRouteType, int pRoutingPlanId) {
{
if (pRouteRecord.RatingInfo == null)
{
throw new Exception(string.Format("ERROR: No Rating Info found for Route={0}", pRouteRecord.FullName));
}
reportStatus(LogSeverity.Status, "DialPlanImporter.importRouteRates", string.Format("Importing Route={0}", pRouteRecord.FullName));
using (var _db = new Rbr_Db()) {
_db.BeginTransaction();
try {
//-- get base RouteRow
var _routeRow = RoutingManager.GetByName(_db, args.CallingPlanId, pRouteRecord.FullName);
if (_routeRow == null)
{
reportStatus(LogSeverity.Status, "DialPlanImporter.importRouteRates", string.Format("SKIPPING: Route={0}, doesn't exists in CallingPlan={1}.", pRouteRecord.FullName, args.CallingPlanId));
return;
}
var _routeType = getRouteType();
int _rateRouteId = getBaseRouteId(_db, _routeType, args.AccountId, args.RoutingPlanId, _routeRow.Route_id);
//-- Expects that imported file has records for Routes whose rates are changing only.
//-- If the rate import record for existing Route is missing; Route is skipped
//-- If the route record is not found we create a new record and add rates to it
//-- Add/Update ratingHistory: default time period today, maxTime used
var _ratingHistoryEntry = new RatingHistoryEntry(_routeType, _rateRouteId, args.From, args.To, pRouteRecord.RatingInfo);
RatingManager.SaveRatingHistoryEntry(_db, _ratingHistoryEntry);
_db.CommitTransaction();
}
catch (Exception _ex) {
_db.RollbackTransaction();
reportStatus(LogSeverity.Error, "DialPlanImporter.importRouteRates", _ex.Message);
throw;
}
}
}
/// <summary>
/// This method schedules dynamically set of rules as defined in orchestrationInput.RoutingRules.
/// It can be optionally used to simplify execution of orchestration.
/// RoutingRules implement usually some kind of Business Rule Engine.
/// </summary>
/// <param name="context"></param>
/// <param name="instance"></param>
/// <returns></returns>
protected async Task <List <RoutingRuleResult> > ScheduleRoutedTasks(OrchestrationContext context,
TaskInput instance)
{
List <RoutingRuleResult> results = new List <RoutingRuleResult>();
RoutingManager mgr = new RoutingManager(context);
var tasks = mgr.ScheduleRoutedTasks(instance, this.Configuration.RoutingRulesPipeline);
await Task.WhenAll(tasks.ToArray());
//bool hasFaulted = false;
foreach (var task in tasks)
{
RoutingRuleResult res;
if (task.IsFaulted)
{
res = new RoutingRuleResult();
res.Exception = task.Exception.InnerExceptions.First().ToString();
//hasFaulted = true;
}
else
{
res = task.Result;
}
results.Add(res);
}
//if (hasFaulted)
// throw new Exception("One or more routed tasks has failed.");
return(results);
}
public RoutingTableDto GetRoutingTable(int pRoutingPlanId, int pBaseRouteId)
{
if (pRoutingPlanId > 0 && pBaseRouteId > 0)
{
using (var _db = new Rbr_Db()) {
var _routingPlanDetailRow = _db.RoutingPlanDetailCollection.GetByPrimaryKey(pRoutingPlanId, pBaseRouteId);
if (_routingPlanDetailRow == null)
{
return(null);
}
var _routingTable = new RoutingTableDto
{
RoutingPlanId = _routingPlanDetailRow.Routing_plan_id,
BaseRouteId = _routingPlanDetailRow.Route_id,
Algorithm = _routingPlanDetailRow.Algorithm,
AvailableTerminations = RoutingManager.GetAvailableTerminations(_db, pBaseRouteId),
Terminations = RoutingManager.GetAll(_db, pRoutingPlanId, pBaseRouteId)
};
return(_routingTable);
}
}
return(null);
}
public HackerNode(RoutingManager routingManager, TcpConnectionManager connectionManager, DataManager dataManager, EncryptionManager encryptionManager, bool doLogMap)
: base(routingManager, connectionManager, dataManager, encryptionManager, doLogMap)
{
}
//------------------------------------- Private ----------------------------------------------
void exportWholesaleRates()
{
try {
countries = new SortedList <string, CountryRecord>();
using (var _db = new Rbr_Db()) {
ServiceDto _service = getService(_db);
RouteRow[] _baseRouteRows = _db.RouteCollection.GetByCallingPlanIdRoutingPlanId(_service.CallingPlanId, args.RoutingPlanId);
if (_baseRouteRows == null || _baseRouteRows.Length <= 0)
{
reportStatus(LogSeverity.Status, "DialPlanExporter.exportWholesaleRates", "WARNING: No Routes to Export...");
return;
}
_baseRouteRows = RoutingManager.SortRouteRows(_baseRouteRows);
string _filePath = getFilePath();
using (var _sw = new StreamWriter(_filePath, false)) {
_sw.WriteLine(args.PerMinute ? RatesFileHeaderCostPerMinute : RatesFileHeaderCostPerIncrements);
int _index = 0;
CountryRecord _countryRecord = null;
foreach (RouteRow _baseRouteRow in _baseRouteRows)
{
host.ReportProgress(_index++ *100 / _baseRouteRows.Length);
WholesaleRouteRow _wholesaleRouteRow = _db.WholesaleRouteCollection.GetByServiceIdBaseRouteId(_service.ServiceId, _baseRouteRow.Route_id);
if (_wholesaleRouteRow == null)
{
continue;
}
if (_countryRecord == null || _countryRecord.Name != _baseRouteRow.Name)
{
_countryRecord = getCountryRecord(_db, _baseRouteRow);
}
RouteRecord _routeRecord = getRouteRecord(_baseRouteRow, _countryRecord);
_countryRecord.Routes.Add(_routeRecord.FullName, _routeRecord);
WholesaleRateHistoryRow _wholesaleRateHistoryRow = _db.WholesaleRateHistoryCollection.GetByWholesaleRouteIdDate(_wholesaleRouteRow.Wholesale_route_id, DateTime.Today);
if (_wholesaleRateHistoryRow != null)
{
RatingInfoDto _ratingInfo = RatingManager.GetRatingInfo(_db, _wholesaleRateHistoryRow.Rate_info_id, false);
if (_ratingInfo == null)
{
reportStatus(LogSeverity.Critical, "DialPlanExporter.exportWholesaleRates", string.Format("RatingInfo == null, {0}", _wholesaleRateHistoryRow.Rate_info_id));
continue;
}
_routeRecord.RatingInfo = _ratingInfo;
reportStatus(LogSeverity.Status, "DialPlanExporter.exportWholesaleRates", string.Format("Exporting Rates for Route: {0}", _routeRecord.FullName));
_sw.Write(_routeRecord.GetRatesAsString(args.PerMinute));
}
}
}
}
}
catch (Exception _ex) {
reportStatus(LogSeverity.Critical, "DialPlanExporter.exportWholesaleRates", string.Format("Exception:\r\n{0}", _ex));
throw;
}
}
void exportDialPlan()
{
countries = new SortedList <string, CountryRecord>();
using (var _db = new Rbr_Db()) {
RouteRow[] _baseRouteRows = getBaseRouteRows(_db);
if (_baseRouteRows == null || _baseRouteRows.Length <= 0)
{
reportStatus(LogSeverity.Status, "DialPlanExporter.exportDialPlan", "No Routes to Process...");
return;
}
_baseRouteRows = RoutingManager.SortRouteRows(_baseRouteRows);
string _filePath = getFilePath();
using (var _swDialPlan = new StreamWriter(_filePath, false)) {
int _index = 0;
CountryRecord _countryRecord = null;
foreach (RouteRow _baseRouteRow in _baseRouteRows)
{
host.ReportProgress(_index++ *100 / _baseRouteRows.Length);
if (args.RoutingPlanId > 0)
{
RoutingPlanDetailRow _routingPlanDetailRow = _db.RoutingPlanDetailCollection.GetByPrimaryKey(args.RoutingPlanId, _baseRouteRow.Route_id);
if (_routingPlanDetailRow == null)
{
continue; //NOTE: skip this route
}
}
if (_countryRecord == null || _countryRecord.Name != _baseRouteRow.Name)
{
_countryRecord = getCountryRecord(_db, _baseRouteRow);
}
if (_countryRecord.Routes.ContainsKey(_baseRouteRow.Name))
{
throw new Exception(string.Format("Unexpected: Route already processed? {0}", _baseRouteRow.Name));
}
RouteRecord _routeRecord = getRouteRecord(_baseRouteRow, _countryRecord);
_countryRecord.Routes.Add(_routeRecord.FullName, _routeRecord);
reportStatus(LogSeverity.Status, "DialPlanExporter.exportDialPlanToFile", string.Format("Exporting DialCodes for Route: {0}", _routeRecord.FullName));
DialCodeRow[] _dialCodeRows = _db.DialCodeCollection.GetByRoute_id(_baseRouteRow.Route_id);
if (_dialCodeRows != null && _dialCodeRows.Length > 0)
{
var _dialCodesAsStringArray = new string[_dialCodeRows.Length];
for (int _i = 0; _i < _dialCodeRows.Length; _i++)
{
_dialCodesAsStringArray[_i] = _dialCodeRows[_i].Dial_code.ToString();
}
_routeRecord.AddDialCodes(_dialCodesAsStringArray);
}
_swDialPlan.Write(_routeRecord.DialCodesAsString);
}
}
}
}
public TestNode(RoutingManager routingManager, TcpConnectionManager connectionManager)
{
this.routingManager = routingManager;
this.connectionManager = connectionManager;
}
public RoutingPlanDto GetRoutingPlan(int pRoutingPlanId)
{
using (var _db = new Rbr_Db()) {
return(RoutingManager.GetRoutingPlan(_db, pRoutingPlanId));
}
}
public RoutingPlanDto[] GetRoutingPlans(int pCallingPlanId)
{
using (var _db = new Rbr_Db()) {
return(RoutingManager.GetRoutingPlans(_db, pCallingPlanId));
}
}
public RoutingPlanDto[] GetRoutingPlans()
{
using (var _db = new Rbr_Db()) {
return(RoutingManager.GetRoutingPlans(_db));
}
}
public BaseRouteDto GetRoute(int pRouteId)
{
using (var _db = new Rbr_Db()) {
return(RoutingManager.GetBaseRoute(_db, pRouteId));
}
}
