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)); } }