Example #1
0
 public static ServiceFunction GetSourceFunction(this ServiceFunction value, int serviceFunctionId)
 {
     using (var sourceDb = new SLMDataContext("Name=SLMSourceDataContext"))
     {
         // For expediency grab everything and store in memory
         return(sourceDb.ServiceFunctions.AsNoTracking()
                .Include(c => c.ServiceDomain)
                .Include(c => c.FunctionType)
                .Include(c => c.ServiceComponents)
                .Include(c => c.ServiceComponents.Select(cc => cc.ChildServiceComponents))
                .Include(c => c.ServiceComponents.Select(r => r.Resolver))
                .Include(c => c.ServiceComponents.Select(r => r.Resolver.OperationalProcessTypes.Select(op => op.OperationalProcessTypeRefData)))
                .Include(c => c.ServiceComponents.Select(r => r.Resolver.ServiceDeliveryOrganisationType))
                .Include(c => c.ServiceComponents.Select(r => r.Resolver.ServiceDeliveryUnitType))
                .Include(c => c.ServiceComponents.Select(r => r.Resolver.ResolverGroupType))
                .Include(c => c.ServiceComponents.Select(r => r.Resolver.ServiceComponent))
                .Include(c => c.ServiceComponents.Select(r => r.Resolver.ServiceDesk))
                .Include(c => c.ServiceComponents.Select(cc => cc.ChildServiceComponents.Select(ccr => ccr.Resolver)))
                .Include(c => c.ServiceComponents.Select(cc => cc.ChildServiceComponents.Select(ccr => ccr.Resolver.OperationalProcessTypes.Select(op => op.OperationalProcessTypeRefData))))
                .Include(c => c.ServiceComponents.Select(cc => cc.ChildServiceComponents.Select(ccr => ccr.Resolver.ServiceDeliveryOrganisationType)))
                .Include(c => c.ServiceComponents.Select(cc => cc.ChildServiceComponents.Select(ccr => ccr.Resolver.ServiceDeliveryUnitType)))
                .Include(c => c.ServiceComponents.Select(cc => cc.ChildServiceComponents.Select(ccr => ccr.Resolver.ResolverGroupType)))
                .Include(c => c.ServiceComponents.Select(cc => cc.ChildServiceComponents.Select(ccr => ccr.Resolver.ServiceComponent)))
                .Include(c => c.ServiceComponents.Select(cc => cc.ChildServiceComponents.Select(ccr => ccr.Resolver.ServiceDesk)))
                .FirstOrDefault(x => x.Id == serviceFunctionId));
     }
 }
        public void ServiceFunctionService_Update_CallUpdatesFunctionAndCallsSaveChanges()
        {
            #region Arrange

            var dateTimeNow = DateTime.Now;

            var serviceFunction = new ServiceFunction
            {
                Id            = 3,
                FunctionType  = _serviceFunctionTypes.FirstOrDefault(x => x.Id == 1),
                ServiceDomain = new ServiceDomain {
                    Id = 1, ServiceDeskId = 1
                },
                InsertedBy   = Username,
                InsertedDate = dateTimeNow,
                UpdatedBy    = Username,
                UpdatedDate  = dateTimeNow,
            };

            #endregion

            #region Act

            _serviceFunctionService.Update(serviceFunction);

            #endregion

            #region Assert

            _mockServiceFunctionRepository.Verify(x => x.Update(It.IsAny <ServiceFunction>()), Times.Once());
            _mockUnitOfWork.Verify(x => x.Save(), Times.Exactly(1));

            #endregion
        }
        private void TransformServiceFunction(ServiceDomain serviceDomain, TemplateRow templateRow)
        {
            var serviceFunction = serviceDomain.ServiceFunctions.FirstOrDefault(d => d.FunctionType.FunctionName.Trim() == templateRow.ServiceFunction.Trim());

            if (serviceFunction == null)
            {
                var dateTimeNow = DateTime.Now;
                serviceFunction = new ServiceFunction
                {
                    ServiceDomain     = serviceDomain,
                    FunctionType      = _functionTypeRefDataService.InsertorUpdate(templateRow.ServiceFunction),
                    ServiceComponents = new List <ServiceComponent>(),
                    DiagramOrder      = 5,
                    InsertedBy        = _userIdentity.Name,
                    InsertedDate      = dateTimeNow,
                    UpdatedBy         = _userIdentity.Name,
                    UpdatedDate       = dateTimeNow
                };

                serviceDomain.ServiceFunctions.Add(serviceFunction);
                _serviceDomainService.Update(serviceDomain);
            }

            if (!string.IsNullOrEmpty(templateRow.ServiceComponentLevel1))
            {
                TransformComponentLevelOne(serviceFunction, templateRow);
            }
        }
        private void TransformComponentLevelOne(ServiceFunction serviceFunction, TemplateRow templateRow)
        {
            var serviceComponent = serviceFunction.ServiceComponents.FirstOrDefault(d => d.ComponentName == templateRow.ServiceComponentLevel1 && d.ComponentLevel == 1);

            if (serviceComponent == null)
            {
                var dateTimeNow = DateTime.Now;
                serviceComponent = new ServiceComponent
                {
                    ServiceFunction   = serviceFunction,
                    ComponentName     = templateRow.ServiceComponentLevel1,
                    ComponentLevel    = 1,
                    ServiceActivities = string.IsNullOrEmpty(templateRow.ServiceComponentLevel2) &&
                                        !string.IsNullOrEmpty(templateRow.ServiceActivities)
                        ? templateRow.ServiceActivities
                        : string.Empty,
                    DiagramOrder = 5,
                    InsertedBy   = _userIdentity.Name,
                    InsertedDate = dateTimeNow,
                    UpdatedBy    = _userIdentity.Name,
                    UpdatedDate  = dateTimeNow
                };

                serviceFunction.ServiceComponents.Add(serviceComponent);
                _serviceFunctionService.Update(serviceFunction);
            }
            //else if (!string.IsNullOrEmpty(templateRow.ServiceActivities))
            //{
            //    if (!string.IsNullOrEmpty(serviceComponent.ServiceActivities))
            //        serviceComponent.ServiceActivities += $"\r\n{templateRow.ServiceActivities}";
            //    else
            //    {
            //        serviceComponent.ServiceActivities = templateRow.ServiceActivities;
            //    }

            //    _serviceComponentService.Update(serviceComponent);
            //}

            if (!string.IsNullOrEmpty(templateRow.ServiceComponentLevel2))
            {
                if (serviceComponent.Resolver != null)
                {
                    throw new DataImportException(
                              $"Error reading Service Decomposition Design spreadsheet. Worksheet, Resolvers and Childs Components detected on Component [{templateRow.ServiceComponentLevel1}].");
                }

                TransformComponentLevelTwo(serviceComponent, templateRow);
            }
            else if (!string.IsNullOrEmpty(templateRow.ServiceDeliveryOrganisation))
            {
                if (serviceComponent.Resolver != null)
                {
                    throw new DataImportException(
                              $"Error reading Service Decomposition Design spreadsheet. Worksheet, Multiple Resolvers per Component detected on Component [{templateRow.ServiceComponentLevel1}].");
                }

                TransformResolver(serviceComponent, templateRow);
            }
        }
 public void Update(ServiceFunction entity)
 {
     RetryableOperation.Invoke(ExceptionPolicies.General,
                               () =>
     {
         _serviceFunctionRepository.Update(entity);
         _unitOfWork.Save();
     });
 }
Example #6
0
 public AdvertiseServiceOptions(string service, ServiceFunction <MReq, MRes> serviceCallback)
 {
     this.Service     = service;
     ServiceCallback  = serviceCallback;
     Helper           = new ServiceCallbackHelper <MReq, MRes>(serviceCallback);
     RequestDataType  = new MReq().MessageType.Replace("/Request", "__Request");
     ResponseDataType = new MRes().MessageType.Replace("/Response", "__Response");
     SrvType          = RequestDataType.Replace("__Request", "");
     Md5Sum           = RosService.Generate(SrvType).MD5Sum();
 }
 public int Create(ServiceFunction entity)
 {
     RetryableOperation.Invoke(ExceptionPolicies.General,
                               () =>
     {
         _serviceFunctionRepository.Insert(entity);
         _unitOfWork.Save();
     });
     return(entity.Id);
 }
 /// <summary>
 ///     Advertises a named ServiceServer
 /// </summary>
 /// <typeparam name="MReq">Request sub-srv type</typeparam>
 /// <typeparam name="MRes">Response sub-srv type</typeparam>
 /// <param name="service">The name of the service to advertise</param>
 /// <param name="srv_func">The handler for the service</param>
 /// <returns>The ServiceServer that will call the ServiceFunction on behalf of ServiceClients</returns>
 public ServiceServer advertiseService <MReq, MRes>(string service, ServiceFunction <MReq, MRes> srv_func)
     where MReq : IRosMessage, new()
     where MRes : IRosMessage, new()
 {
     if (started_by_visual_studio)
     {
         return(null);
     }
     return(advertiseService(new AdvertiseServiceOptions <MReq, MRes>(service, srv_func)));
 }
        public ServiceFunction GetById(int id)
        {
            ServiceFunction result = null;

            RetryableOperation.Invoke(ExceptionPolicies.General,
                                      () =>
            {
                result = _serviceFunctionRepository.GetById(id);
            });
            return(result);
        }
Example #10
0
 public AdvertiseServiceOptions(string service, ServiceFunction <MReq, MRes> serviceCallback)
 {
     this.service = service;
     srv_func     = serviceCallback;
     helper       = new ServiceCallbackHelper <MReq, MRes>(serviceCallback);
     req_datatype = new MReq().MessageType.Replace("/Request", "__Request");
     res_datatype = new MRes().MessageType.Replace("/Response", "__Response");
     SrvType      = req_datatype.Replace("__Request", "");
     datatype     = SrvType;
     md5sum       = RosService.Generate(SrvType).MD5Sum();
 }
 public void init(string service, ServiceFunction <MReq, MRes> callback)
 {
     this.service = service;
     srv_func     = callback;
     helper       = new ServiceCallbackHelper <MReq, MRes>(callback);
     req_datatype = new MReq().msgtype.ToString().Replace("__", "/").Replace("/Request", "__Request");
     res_datatype = new MRes().msgtype.ToString().Replace("__", "/").Replace("/Response", "__Response");
     srvtype      = (SrvTypes)Enum.Parse(typeof(SrvTypes), req_datatype.Replace("__Request", "").Replace("/", "__"));
     datatype     = srvtype.ToString().Replace("__", "/");
     md5sum       = IRosService.generate(srvtype).MD5Sum;
 }
Example #12
0
 public ServiceComponentProcessor(ServiceDesk serviceDesk,
                                  ServiceFunction serviceFunction,
                                  ServiceComponent serviceComponent,
                                  ISLMDataContext dataContext,
                                  IUnitOfWork unitOfWork)
 {
     _serviceDesk      = serviceDesk;
     _serviceFunction  = serviceFunction;
     _serviceComponent = serviceComponent;
     _dataContext      = dataContext;
     _unitOfWork       = unitOfWork;
 }
Example #13
0
 public ChildServiceComponentProcessor(ServiceDesk serviceDesk,
                                       ServiceFunction serviceFunction,
                                       ServiceComponent parentServiceComponent,
                                       IEnumerable <ServiceComponent> childServiceComponents,
                                       ISLMDataContext dataContext,
                                       IUnitOfWork unitOfWork)
 {
     _serviceDesk            = serviceDesk;
     _serviceFunction        = serviceFunction;
     _parentServiceComponent = parentServiceComponent;
     _childServiceComponents = childServiceComponents;
     _dataContext            = dataContext;
     _unitOfWork             = unitOfWork;
 }
        public void Execute()
        {
            foreach (var serviceFunction in _serviceFunctions)
            {
                var serviceFunctionTypeRefData = serviceFunction.FunctionType;
                if (!_dataContext.FunctionTypeRefData.Any(x => x.FunctionName == serviceFunctionTypeRefData.FunctionName))
                {
                    var functionType = new FunctionTypeRefData
                    {
                        FunctionName = serviceFunctionTypeRefData.FunctionName,
                        Visible      = serviceFunctionTypeRefData.Visible,
                        SortOrder    = serviceFunctionTypeRefData.SortOrder
                    };

                    _dataContext.FunctionTypeRefData.Add(functionType);
                    _unitOfWork.Save();
                }

                var functionTypeRefData = _dataContext.FunctionTypeRefData.Single(x => x.FunctionName == serviceFunctionTypeRefData.FunctionName);

                var newServiceFunction = new ServiceFunction
                {
                    ServiceDomainId   = _serviceDomain.Id,
                    ServiceDomain     = _serviceDomain,
                    FunctionType      = functionTypeRefData,
                    FunctionTypeId    = functionTypeRefData.Id,
                    AlternativeName   = serviceFunction.AlternativeName,
                    ServiceComponents = new List <ServiceComponent>(),
                    InsertedBy        = serviceFunction.InsertedBy,
                    InsertedDate      = serviceFunction.InsertedDate,
                    UpdatedBy         = serviceFunction.UpdatedBy,
                    UpdatedDate       = serviceFunction.UpdatedDate
                };

                _serviceDomain.ServiceFunctions.Add(newServiceFunction);
                _unitOfWork.Save();
            }
        }
        public void Delete(ServiceFunction entity)
        {
            RetryableOperation.Invoke(ExceptionPolicies.General,
                                      () =>
            {
                // Get a new sql connection from the unit of work
                using (var dbConnection = _unitOfWork.CreateConnection())
                {
                    // Create a null transaction
                    SqlTransaction transaction = null;

                    try
                    {
                        // Open the connection and begin a transaction
                        dbConnection.Open();
                        transaction = dbConnection.BeginTransaction();

                        // Execute the stored procedure to delete the customer
                        _unitOfWork.ExecuteNonQueryStoredProcedure("spDeleteServiceFunction",
                                                                   dbConnection,
                                                                   transaction,
                                                                   new SqlParameter("@ServiceFunctionId", SqlDbType.Int)
                        {
                            Value = entity.Id
                        });

                        // Command has executed successfully, commit the transaction
                        transaction.Commit();
                    }
                    catch (Exception)
                    {
                        // If we have a transaction then roll it back
                        transaction?.Rollback();
                        throw;
                    }
                }
            });
        }
        public void ServiceFunctionService_Create_CallInsertsFunctionAndCallsSaveChanges()
        {
            #region Arrange

            var dateTimeNow = DateTime.Now;

            var serviceFunction = new ServiceFunction()
            {
                Id            = 5,
                FunctionType  = _serviceFunctionTypes.FirstOrDefault(x => x.Id == 1),
                ServiceDomain = new ServiceDomain {
                    Id = 1, ServiceDeskId = 1
                },
                InsertedBy   = Username,
                InsertedDate = dateTimeNow,
                UpdatedBy    = Username,
                UpdatedDate  = dateTimeNow,
            };

            #endregion

            #region Act

            var response = _serviceFunctionService.Create(serviceFunction);

            #endregion

            #region Assert

            _mockServiceFunctionRepository.Verify(x => x.Insert(It.IsAny <ServiceFunction>()), Times.Once());
            _mockUnitOfWork.Verify(x => x.Save(), Times.Exactly(1));

            Assert.IsNotNull(response);
            Assert.AreEqual(_serviceFunctions.Count, response);

            #endregion
        }
 public ServiceCallbackHelper(ServiceFunction <MReq, MRes> srv_func)
 {
     // TODO: Complete member initialization
     _callback = srv_func;
 }
 public AdvertiseServiceOptions(string service, ServiceFunction <MReq, MRes> srv_func)
 {
     // TODO: Complete member initialization
     init(service, srv_func);
 }
Example #19
0
 /// <summary>
 ///     Advertises a named ServiceServer
 /// </summary>
 /// <typeparam name="MReq">Request sub-srv type</typeparam>
 /// <typeparam name="MRes">Response sub-srv type</typeparam>
 /// <param name="service">The name of the service to advertise</param>
 /// <param name="srv_func">The handler for the service</param>
 /// <returns>The ServiceServer that will call the ServiceFunction on behalf of ServiceClients</returns>
 public ServiceServer advertiseService <MReq, MRes>(string service, ServiceFunction <MReq, MRes> srv_func)
     where MReq : IRosMessage, new()
     where MRes : IRosMessage, new()
 {
     return(advertiseService(new AdvertiseServiceOptions <MReq, MRes>(service, srv_func)));
 }
Example #20
0
 protected IServiceCallbackHelper(ServiceFunction <RosMessage, RosMessage> callback)
 {
     this.callback = callback;
 }
Example #21
0
 public ServiceCallbackHelper(ServiceFunction <MReq, MRes> srv_func)
 {
     callback = srv_func;
 }
Example #22
0
        public ActionResult CreateAjaxServiceAddFunctionGrid([DataSourceRequest] DataSourceRequest request,
                                                             [Bind(Prefix = "models")] IEnumerable <BulkServiceFunctionViewModel> serviceFunctions)
        {
            var inputFunctions  = serviceFunctions as IList <BulkServiceFunctionViewModel> ?? serviceFunctions.ToList();
            var outputFunctions = new List <BulkServiceFunctionViewModel>();

            if (ModelState.IsValid)
            {
                try
                {
                    var customerSpecificTypeThreshold = _parameterService.GetParameterByNameAndCache <int>(ParameterNames.CustomerSpecificTypeThreshold);

                    if (serviceFunctions != null && inputFunctions.Any())
                    {
                        var userName   = _contextManager.UserManager.Name;
                        var now        = DateTime.Now;
                        var customerId = _appUserContext.Current.CurrentCustomer.Id;

                        // Make sure all the of the specified Service Domains exist.
                        var checkServiceDomainIds = inputFunctions
                                                    .Where(w => w.ServiceDomainId.HasValue)
                                                    .Select(s => s.ServiceDomainId.Value)
                                                    .Distinct()
                                                    .ToList();
                        var serviceDomainIds = _serviceDomainService.GetByCustomer(customerId)
                                               .Where(w => checkServiceDomainIds.Contains(w.Id))
                                               .Select(s => s.Id)
                                               .ToList();

                        foreach (var inputFunction in inputFunctions)
                        {
                            if (!inputFunction.ServiceDomainId.HasValue ||
                                inputFunction.ServiceDomainId == 0 ||
                                inputFunction.FunctionTypeId == 0 ||
                                !serviceDomainIds.Contains(inputFunction.ServiceDomainId.Value))
                            {
                                continue;
                            }

                            var diagramDisplayOrder = inputFunction.DiagramOrder ?? 5;
                            if (diagramDisplayOrder < 1)
                            {
                                diagramDisplayOrder = 5;
                            }

                            var newServiceFunction = new ServiceFunction
                            {
                                AlternativeName = inputFunction.AlternativeName,
                                DiagramOrder    = diagramDisplayOrder,
                                FunctionTypeId  = inputFunction.FunctionTypeId,
                                ServiceDomainId = inputFunction.ServiceDomainId.Value,
                                InsertedBy      = userName,
                                InsertedDate    = now,
                                UpdatedBy       = userName,
                                UpdatedDate     = now
                            };

                            newServiceFunction.Id = _serviceFunctionService.Create(newServiceFunction);
                            outputFunctions.Add(Mapper.Map <BulkServiceFunctionViewModel>(newServiceFunction));

                            var functionType = _functionTypeRefDataService.GetById(inputFunction.FunctionTypeId);
                            if (!functionType.Visible && _functionTypeRefDataService.GetNumberOfFunctionTypeReferences(inputFunction.FunctionTypeId) >= customerSpecificTypeThreshold)
                            {
                                functionType.Visible = true;
                                _functionTypeRefDataService.Update(functionType);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    _contextManager.ResponseManager.StatusCode = 500;
                    _contextManager.ResponseManager.AppendHeader(ModelStateErrorNames.ErrorMessage, ex.Message);
                }
            }

            return(Json(outputFunctions.ToDataSourceResult(request, ModelState)));
        }
Example #23
0
 public virtual ServiceFunction <RosMessage, RosMessage> Callback(ServiceFunction <RosMessage, RosMessage> cb)
 {
     callback = cb;
     return(callback);
 }
Example #24
0
        public void Execute()
        {
            // HMRC
            // =====
            // xxx = HMRC FAST-DA ( * - Copied )

            // Domains
            // ========
            // xxx = Network Services (Source)
            // xxx = Security Services (Target)

            var sourceFunctionId = 978;
            var targetDomainId   = 280;

            var serviceFunction = new ServiceFunction().GetSourceFunction(sourceFunctionId);

            if (serviceFunction != null)
            {
                using (var targetDbContext = new SLMDataContext("Name=SLMTargetDataContext"))
                {
                    var unitOfWork = new UnitOfWork(targetDbContext);
                    IRepositoryTransaction repositoryTransaction = null;

                    using (var dbConnection = unitOfWork.CreateConnection())
                    {
                        try
                        {
                            // Open the connection and begin a transaction
                            dbConnection.Open();
                            repositoryTransaction = unitOfWork.BeginTransaction();

                            var targetDomain = targetDbContext.ServiceDomains.Single(x => x.Id == targetDomainId);

                            var serviceFunctions = new List <ServiceFunction> {
                                serviceFunction
                            };

                            var serviceFunctionProcessor = new ServiceFunctionProcessor(targetDomain, serviceFunctions, targetDbContext, unitOfWork);
                            serviceFunctionProcessor.Execute();

                            var targetServiceFunction = targetDomain.ServiceFunctions.Single(x => x.FunctionType.FunctionName == serviceFunction.FunctionType.FunctionName);
                            // Add underlying Service Function hierarchy
                            foreach (var serviceComponent in serviceFunction.ServiceComponents.Where(x => x.ComponentLevel == 1))
                            {
                                var serviceComponentProcessor = new ServiceComponentProcessor(targetDomain.ServiceDesk, targetServiceFunction, serviceComponent, targetDbContext, unitOfWork);
                                serviceComponentProcessor.Execute();
                            }

                            repositoryTransaction?.Save();
                            System.Console.WriteLine($@"Successfully Copied Service Function [{serviceFunction.FunctionType.FunctionName}] To Service Domain [{targetDomain.DomainType.DomainName}]");
                        }
                        catch (Exception ex)
                        {
                            // If we have a transaction then roll it back
                            repositoryTransaction?.Rollback();

                            System.Console.WriteLine($@"Exception => {ex.Message}");
                        }
                    }
                }
            }
        }
 protected IServiceCallbackHelper(ServiceFunction <IRosMessage, IRosMessage> Callback)
 {
     //EDB.WriteLine("ISubscriptionCallbackHelper: 1 arg constructor");
     //throw new NotImplementedException();
     _callback = Callback;
 }
Example #26
0
        public static void ProcessServiceComponents(this ChartDataListItem chartData,
                                                    bool resolvers,
                                                    bool svcActivities,
                                                    bool opProcs,
                                                    string customerName,
                                                    ServiceFunction domainFunction,
                                                    List <List <DotMatrixListItem> > dotMatrix)
        {
            if (domainFunction.ServiceComponents == null)
            {
                return;
            }

            foreach (var parentComponent in domainFunction.ServiceComponents.Where(x => x.ComponentLevel == 1).OrderBy(x => x.DiagramOrder).ThenBy(x => x.ComponentName).ToList())
            {
                var parentComponentListItem = new ChartDataListItem
                {
                    Id            = parentComponent.Id,
                    Title         = parentComponent.ComponentName,
                    Type          = DecompositionType.Component.ToString(),
                    CenteredTitle = string.Empty,
                    Units         = new List <ChartDataListItem>()
                };

                if (parentComponent.ChildServiceComponents != null && parentComponent.ChildServiceComponents.Count > 0)
                {
                    foreach (var childComponent in parentComponent.ChildServiceComponents.OrderBy(x => x.DiagramOrder).ThenBy(x => x.ComponentName))
                    {
                        // Add Child Component
                        var childComponentListItem =
                            new ChartDataListItem
                        {
                            Id            = childComponent.Id,
                            Title         = childComponent.ComponentName,
                            Type          = DecompositionType.Component.ToString(),
                            CenteredTitle = string.Empty,
                            Units         = new List <ChartDataListItem>()
                        };

                        if (resolvers)
                        {
                            childComponentListItem.ProcessResolvers(svcActivities, opProcs, customerName, childComponent, dotMatrix);
                        }
                        else if (svcActivities)
                        {
                            childComponentListItem.ProcessServiceActivities(opProcs, childComponent, dotMatrix);
                        }

                        parentComponentListItem.Units.Add(childComponentListItem);
                    }
                }
                else if (resolvers || svcActivities)
                {
                    // Create A Dummy Child Component
                    var childComponentListItem = new ChartDataListItem
                    {
                        Id            = 0,
                        Title         = string.Empty,
                        CenteredTitle = string.Empty,
                        Type          = DecompositionType.LineForDummyChildComponent.ToString(),
                        Units         = new List <ChartDataListItem>()
                    };

                    if (resolvers)
                    {
                        childComponentListItem.ProcessResolvers(svcActivities, opProcs, customerName, parentComponent, dotMatrix);
                    }
                    else
                    {
                        childComponentListItem.ProcessServiceActivities(opProcs, parentComponent, dotMatrix);
                    }

                    if (childComponentListItem.Units.Any())
                    {
                        parentComponentListItem.Units.Add(childComponentListItem);
                    }
                }

                chartData.Units.Add(parentComponentListItem);
            }
        }
 public virtual ServiceFunction <IRosMessage, IRosMessage> callback(ServiceFunction <IRosMessage, IRosMessage> cb)
 {
     _callback = cb;
     return(_callback);
 }
 protected IServiceCallbackHelper(ServiceFunction <RosMessage, RosMessage> Callback)
 {
     _callback = Callback;
 }