public void RegisterCaps(IRegionClientCapsService service)
        {
            IConfig displayNamesConfig = service.ClientCaps.Registry.RequestModuleInterface<ISimulationBase>().ConfigSource.Configs["DisplayNamesModule"];
            if (displayNamesConfig != null)
            {
                if (!displayNamesConfig.GetBoolean ("Enabled", true))
                    return;
                string bannedNamesString = displayNamesConfig.GetString ("BannedUserNames", "");
                if (bannedNamesString != "")
                    bannedNames = new List<string> (bannedNamesString.Split (','));
            }
            m_service = service;
            m_profileConnector = Aurora.DataManager.DataManager.RequestPlugin<IProfileConnector> ();
            m_eventQueue = service.Registry.RequestModuleInterface<IEventQueueService> ();
            m_userService = service.Registry.RequestModuleInterface<IUserAccountService> ();

            string post = CapsUtil.CreateCAPS ("SetDisplayName", "");
            service.AddCAPS ("SetDisplayName", post);
            service.AddStreamHandler ("SetDisplayName", new RestHTTPHandler ("POST", post,
                                                      ProcessSetDisplayName));

            post = CapsUtil.CreateCAPS ("GetDisplayNames", "");
            service.AddCAPS ("GetDisplayNames", post);
            service.AddStreamHandler ("GetDisplayNames", new StreamHandler ("GET", post,
                                                      ProcessGetDisplayName));
        }

 public TransferController(ITransferService transferService,ICommonService commonService,IUserAccountService userAccountService, ICommodityService commodityService)
 {
     _transferService = transferService;
     _commonService = commonService;
     _userAccountService = userAccountService;
     _commodityService = commodityService;
 }

        public HGAssetService(IConfigSource config, string configName) : base(config, configName)
        {
            m_log.Debug("[HGAsset Service]: Starting");
            IConfig assetConfig = config.Configs[configName];
            if (assetConfig == null)
                throw new Exception("No HGAssetService configuration");

            string userAccountsDll = assetConfig.GetString("UserAccountsService", string.Empty);
            if (userAccountsDll == string.Empty)
                throw new Exception("Please specify UserAccountsService in HGAssetService configuration");

            Object[] args = new Object[] { config };
            m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(userAccountsDll, args);
            if (m_UserAccountService == null)
                throw new Exception(String.Format("Unable to create UserAccountService from {0}", userAccountsDll));

            // legacy configuration [obsolete]
            m_HomeURL = assetConfig.GetString("ProfileServerURI", string.Empty);
            // Preferred
            m_HomeURL = assetConfig.GetString("HomeURI", m_HomeURL);

            m_Cache = UserAccountCache.CreateUserAccountCache(m_UserAccountService);

            // Permissions
            m_AssetPerms = new AssetPermissions(assetConfig);

        }

 public ValidatedPaymentRequestController(IBusinessProcessService paramBusinessProcessService
                                 , IBusinessProcessStateService paramBusinessProcessStateService
                                 , IApplicationSettingService paramApplicationSettingService
                                 , ITransportOrderService paramTransportOrderService
                                 , ITransporterAgreementVersionService transporterAgreementVersionService
                                 , IWorkflowStatusService workflowStatusService, ITransporterService transporterService
                                 , ITransporterChequeService transporterChequeService, IUserProfileService userProfileService 
                                 ,ITransporterPaymentRequestService transporterPaymentRequestService, IBidWinnerService bidWinnerService
                                 , IUserAccountService userAccountService, IDispatchService dispatchService
                                , ITransporterChequeDetailService transporterChequeDetailService,ITransportOrderDetailService transportOrderDetailService)
 {
     _businessProcessService = paramBusinessProcessService;
         _businessProcessStateService = paramBusinessProcessStateService;
         _applicationSettingService = paramApplicationSettingService;
         _transportOrderService = paramTransportOrderService;
         _transporterAgreementVersionService = transporterAgreementVersionService;
         _workflowStatusService = workflowStatusService;
         _transporterService = transporterService;
         _transporterChequeService = transporterChequeService;
          _userProfileService = userProfileService;
         _transporterPaymentRequestService = transporterPaymentRequestService;
         _bidWinnerService = bidWinnerService;
         _userAccountService = userAccountService;
         _dispatchService = dispatchService;
         _transporterChequeDetailService = transporterChequeDetailService;
        _transportOrderDetailService = transportOrderDetailService;
 }

 public ReliefRequisitionController(
     IReliefRequisitionService reliefRequisitionService, 
     IWorkflowStatusService workflowStatusService, 
     IReliefRequisitionDetailService reliefRequisitionDetailService,
     IUserAccountService userAccountService,
     IRegionalRequestService regionalRequestService,
     IRationService rationService, 
     IDonorService donorService, 
     INotificationService notificationService, 
     IPlanService planService,
     ITransactionService transactionService,
     ICommonService commonService, IRationDetailService rationDetailService)
 {
     this._reliefRequisitionService = reliefRequisitionService;
     this._workflowStatusService = workflowStatusService;
     this._reliefRequisitionDetailService = reliefRequisitionDetailService;
     _userAccountService = userAccountService;
     _rationService = rationService;
     _donorService = donorService;
     _notificationService = notificationService;
     _planService = planService;
     _transactionService = transactionService;
     _commonService = commonService;
     _rationDetailService = rationDetailService;
     _regionalRequestService = regionalRequestService;
 }

        public void RegisterCaps (IRegionClientCapsService service)
        {
            var cfgservice = service.ClientCaps.Registry.RequestModuleInterface<ISimulationBase> ();
            var displayNamesConfig = cfgservice.ConfigSource.Configs ["DisplayNames"];
            if (displayNamesConfig != null) {
                if (!displayNamesConfig.GetBoolean ("Enabled", true))
                    return;

                string bannedNamesString = displayNamesConfig.GetString ("BannedUserNames", "");
                if (bannedNamesString != "")
                    bannedNames = new List<string> (bannedNamesString.Split (','));

                m_update_days = displayNamesConfig.GetDouble ("UpdateDays", m_update_days);

            }
            m_service = service;
            m_profileConnector = Framework.Utilities.DataManager.RequestPlugin<IProfileConnector> ();
            m_eventQueue = service.Registry.RequestModuleInterface<IEventQueueService> ();
            m_userService = service.Registry.RequestModuleInterface<IUserAccountService> ();

            string post = CapsUtil.CreateCAPS ("SetDisplayName", "");
            service.AddStreamHandler ("SetDisplayName", new GenericStreamHandler ("POST", post, ProcessSetDisplayName));

            post = CapsUtil.CreateCAPS ("GetDisplayNames", "");
            service.AddStreamHandler ("GetDisplayNames", new GenericStreamHandler ("GET", post, ProcessGetDisplayName));
        }

        /// <summary>
        ///   Resolve an osp string into the most suitable internal OpenSim identifier.
        /// </summary>
        /// In some cases this will be a UUID if a suitable profile exists on the system.  In other cases, this may
        /// just return the same identifier after creating a temporary profile.
        /// <param name = "ospa"></param>
        /// <param name = "commsManager"></param>
        /// <returns>
        ///   A suitable UUID for use in Second Life client communication.  If the string was not a valid ospa, then UUID.Zero
        ///   is returned.
        /// </returns>
        public static UUID ResolveOspa(string ospa, IUserAccountService userService)
        {
            if (!ospa.StartsWith(OSPA_PREFIX))
                return UUID.Zero;

//            MainConsole.Instance.DebugFormat("[OSP RESOLVER]: Resolving {0}", ospa);

            string ospaMeat = ospa.Substring(OSPA_PREFIX.Length);
            string[] ospaTuples = ospaMeat.Split(OSPA_TUPLE_SEPARATOR_ARRAY);

            foreach (string tuple in ospaTuples)
            {
                int tupleSeparatorIndex = tuple.IndexOf(OSPA_PAIR_SEPARATOR);

                if (tupleSeparatorIndex < 0)
                {
                    MainConsole.Instance.WarnFormat("[OSP RESOLVER]: Ignoring non-tuple component {0} in OSPA {1}", tuple, ospa);
                    continue;
                }

                string key = tuple.Remove(tupleSeparatorIndex).Trim();
                string value = tuple.Substring(tupleSeparatorIndex + 1).Trim();

                if (OSPA_NAME_KEY == key)
                    return ResolveOspaName(value, userService);
            }

            return UUID.Zero;
        }

 // private readonly IUserAccountService _userAccountService;
 public UsersController(IUserAccountService service, IHubService hubService, IAdminUnitService adminUnitService)
 {
     _userService = service;
     _hubService = hubService;
     _adminUnitService = adminUnitService;
     //_userAccountService = userAccountService;
 }

 public RequestController(IRegionalRequestService reliefRequistionService,
                         IFDPService fdpService,
                         IRegionalRequestDetailService reliefRequisitionDetailService,
                         ICommonService commonService,
                         IHRDService hrdService,
                         IApplicationSettingService ApplicationSettingService,
                         IUserAccountService userAccountService,
                         ILog log,
                         IHRDDetailService hrdDetailService,
                         IRegionalPSNPPlanDetailService regionalPSNPPlanDetailService,
                         IRegionalPSNPPlanService RegionalPSNPPlanService, 
     IAdminUnitService adminUnitService, 
     IPlanService planService, 
     IIDPSReasonTypeServices idpsReasonTypeServices)
 {
     _regionalRequestService = reliefRequistionService;
     _fdpService = fdpService;
     _regionalRequestDetailService = reliefRequisitionDetailService;
     _commonService = commonService;
     _hrdService = hrdService;
     _applicationSettingService = ApplicationSettingService;
     _userAccountService = userAccountService;
     _log = log;
     _HRDDetailService = hrdDetailService;
     _RegionalPSNPPlanDetailService = regionalPSNPPlanDetailService;
     _RegionalPSNPPlanService = RegionalPSNPPlanService;
     _adminUnitService = adminUnitService;
     _planService = planService;
     _idpsReasonTypeServices = idpsReasonTypeServices;
 }

        // Our service
        // see WxServiceBase. That is where most of the configuration
        // for this is done. In this file we are setting up the external
        // and internal services our endpoints will use...
        public WxExampleService(IConfigSource config)
            : base(config)
        {
            m_log.Info("[WxExampleService]: Wx Loading ... ");
            m_config = config;
            IConfig WxConfig = config.Configs["WxExampleService"];
            if (WxConfig != null)
            {
                // loading the UserAccountService so we can use it's methods in our example
                // see below: GetUserData(UUID userID)
                //
                // Read the configuration...
                string userService = WxConfig.GetString("UserAccountService", String.Empty);

                // Load it...
                if (userService != String.Empty)
                {
                    Object[] args = new Object[] { config };
                    m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(userService, args);
                }
            }

            // Add a command to the console
            if (MainConsole.Instance != null)
            {
                MainConsole.Instance.Commands.AddCommand("Wx", true,
                            "show names",
                            "show names",
                            "Show list of names",
                            String.Empty,
                            HandleShowNames);
            }
        }

 public virtual void Start(IConfigSource config, IRegistryCore registry)
 {
     m_Database = Aurora.DataManager.DataManager.RequestPlugin<IInventoryData> ();
     m_UserAccountService = registry.RequestModuleInterface<IUserAccountService>();
     m_LibraryService = registry.RequestModuleInterface<ILibraryService>();
     m_AssetService = registry.RequestModuleInterface<IAssetService>();
 }

 //private readonly IUserProfileService _userProfileService;
 public TransportRequisitionController(
     ITransportRequisitionService transportRequisitionService,
     IWorkflowStatusService workflowStatusService,
     IUserAccountService userAccountService,
     ILog log,
     IAdminUnitService adminUnitService,
     IProgramService programService,
     IReliefRequisitionService reliefRequisitionService,
     IHubAllocationService hubAllocationService,
     IProjectCodeAllocationService projectCodeAllocationService,
     IReliefRequisitionDetailService reliefRequisitionDetailService,
     IRationService rationService, INotificationService notificationService)
 {
     this._transportRequisitionService = transportRequisitionService;
     _workflowStatusService = workflowStatusService;
     _userAccountService = userAccountService;
     _log = log;
     _adminUnitService = adminUnitService;
     _programService = programService;
     _reliefRequisitionService = reliefRequisitionService;
     _hubAllocationService = hubAllocationService;
     _projectCodeAllocationService = projectCodeAllocationService;
     _reliefRequisitionDetailService = reliefRequisitionDetailService;
     _reliefRequisitionService = reliefRequisitionService;
     _rationService = rationService;
     _notificationService = notificationService;
     //_userProfileService = userProfileService;
 }

        public BanCheck(IConfigSource source, IUserAccountService UserAccountService)
        {
            IConfig config = source.Configs["GrieferProtection"];
            if (config == null)
                return;

            m_enabled = config.GetBoolean("Enabled", true);

            if (!m_enabled)
                return;

            string bannedViewers = config.GetString("ViewersToBan", "");
            m_bannedViewers = Util.ConvertToList(bannedViewers, false);
            string allowedViewers = config.GetString("ViewersToAllow", "");
            m_allowedViewers = Util.ConvertToList(allowedViewers, false);
            m_useIncludeList = config.GetBoolean("UseAllowListInsteadOfBanList", false);

            m_checkOnLogin = config.GetBoolean("CheckForSimilaritiesOnLogin", m_checkOnLogin);
            m_checkOnTimer = config.GetBoolean("CheckForSimilaritiesOnTimer", m_checkOnTimer);

            if (m_checkOnTimer)
                _checkForSimilaritiesLater.Start(5, CheckForSimilaritiesMultiple);

            GrieferAllowLevel =
                (AllowLevel) Enum.Parse(typeof (AllowLevel), config.GetString("GrieferAllowLevel", "AllowKnown"));

            presenceInfo = Framework.Utilities.DataManager.RequestPlugin<IPresenceInfo>();
            m_accountService = UserAccountService;

            if (!m_accountService.RemoteCalls())
                AddCommands ();                     // only add if we are local
        }

        public HGInventoryService(IConfigSource config, string configName)
            : base(config, configName)
        {
            m_log.Debug("[HGInventory Service]: Starting");
            if (configName != string.Empty)
                m_ConfigName = configName;

            //
            // Try reading the [InventoryService] section, if it exists
            //
            IConfig invConfig = config.Configs[m_ConfigName];
            if (invConfig != null)
            {                
                // realm = authConfig.GetString("Realm", realm);
                string userAccountsDll = invConfig.GetString("UserAccountsService", string.Empty);
                if (userAccountsDll == string.Empty)
                    throw new Exception("Please specify UserAccountsService in HGInventoryService configuration");

                Object[] args = new Object[] { config };
                m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(userAccountsDll, args);
                if (m_UserAccountService == null)
                    throw new Exception(String.Format("Unable to create UserAccountService from {0}", userAccountsDll));

                m_HomeURL = Util.GetConfigVarFromSections<string>(config, "HomeURI",
                    new string[] { "Startup", "Hypergrid", m_ConfigName }, String.Empty); 

                m_Cache = UserAccountCache.CreateUserAccountCache(m_UserAccountService);
            }

            m_log.Debug("[HG INVENTORY SERVICE]: Starting...");
        }

        public DeliveryController(ITransportOrderService transportOrderService,
                                      IWorkflowStatusService workflowStatusService,
                                      IDispatchAllocationService dispatchAllocationService,
                                      IDeliveryService deliveryService,
            IDispatchService dispatchService,
            IDeliveryDetailService deliveryDetailService,
            INotificationService notificationService, IActionTypesService actionTypeService, IUserAccountService userAccountService,
            Cats.Services.EarlyWarning.ICommodityService commodityService, Cats.Services.EarlyWarning.IUnitService unitService,
            Cats.Services.Transaction.ITransactionService transactionService, IBusinessProcessService businessProcessService, IApplicationSettingService applicationSettingService, ITransporterPaymentRequestService transporterPaymentRequestService)
        {
            _transportOrderService = transportOrderService;
            _workflowStatusService = workflowStatusService;
            _dispatchAllocationService = dispatchAllocationService;
            _deliveryService = deliveryService;
            _dispatchService = dispatchService;
            _deliveryDetailService = deliveryDetailService;
            _notificationService = notificationService;

            _actionTypeService = actionTypeService;

            _userAccountService = userAccountService;
            _commodityService = commodityService;
            _unitService = unitService;
            _transactionService = transactionService;
            _businessProcessService = businessProcessService;
            _applicationSettingService = applicationSettingService;
            _transporterPaymentRequestService = transporterPaymentRequestService;
        }

        public HGAssetService(IConfigSource config, string configName) : base(config, configName)
        {
            m_log.Debug("[HGAsset Service]: Starting");
            IConfig assetConfig = config.Configs[configName];
            if (assetConfig == null)
                throw new Exception("No HGAssetService configuration");

            string userAccountsDll = assetConfig.GetString("UserAccountsService", string.Empty);
            if (userAccountsDll == string.Empty)
                throw new Exception("Please specify UserAccountsService in HGAssetService configuration");

            Object[] args = new Object[] { config };
            m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(userAccountsDll, args);
            if (m_UserAccountService == null)
                throw new Exception(String.Format("Unable to create UserAccountService from {0}", userAccountsDll));

            m_HomeURL = Util.GetConfigVarFromSections<string>(config, "HomeURI",
                new string[] { "Startup", "Hypergrid", configName }, string.Empty);
            if (m_HomeURL == string.Empty)
                throw new Exception("[HGAssetService] No HomeURI specified");

            m_Cache = UserAccountCache.CreateUserAccountCache(m_UserAccountService);

            // Permissions
            m_AssetPerms = new AssetPermissions(assetConfig);

        }

 public TransporterPaymentRequestController(IBusinessProcessService _paramBusinessProcessService
                                            , IBusinessProcessStateService _paramBusinessProcessStateService
                                            , IApplicationSettingService _paramApplicationSettingService
                                            , ITransporterPaymentRequestService transporterPaymentRequestService
                                            , ITransportOrderService _paramTransportOrderService
                                            , IBidWinnerService bidWinnerService
                                            , IDispatchService dispatchService
                                            , IWorkflowStatusService workflowStatusService
                                            , IUserAccountService userAccountService
                                            , Services.Procurement.ITransporterService transporterService,
                                            ITransportOrderService transportOrderService,
                                            ITransportOrderDetailService transportOrderDetailService, ICommonService commodityService
                                            , IFlowTemplateService flowTemplateService)
 {
     _BusinessProcessService = _paramBusinessProcessService;
     _BusinessProcessStateService = _paramBusinessProcessStateService;
     _ApplicationSettingService = _paramApplicationSettingService;
     _transporterPaymentRequestService = transporterPaymentRequestService;
     _TransportOrderService = _paramTransportOrderService;
     _bidWinnerService = bidWinnerService;
     _dispatchService = dispatchService;
     _workflowStatusService = workflowStatusService;
     _userAccountService = userAccountService;
     _transporterService = transporterService;
     _transportOrderService = transportOrderService;
     _transportOrderDetailService = transportOrderDetailService;
     _commodityService = commodityService;
     _flowTemplateService = flowTemplateService;
 }

 public DashboardController(INotificationService notificationService, IUserAccountService userAccountService)
 {
     _notificationService = notificationService;
     _userAccountService = userAccountService;
     this._dashboardService = new Cats.Services.EarlyWarning.DashboardService();
     this._needAssessmentSummaryService = new Cats.Services.Common.NeedAssessmentSummaryService();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AccountController"/> class.
 /// </summary>
 /// <param name="userService">The user service.</param>
 /// <param name="authenticationService">The authentication service.</param>
 /// <param name="messageBus">The message bus.</param>
 /// <param name="membershipSettings"></param>
 public AccountController(IUserAccountService userService, IAuthenticationService authenticationService, IMessageBus messageBus, IMembershipSettings membershipSettings)
 {
     _membershipSettings = membershipSettings;
     _messageBus = messageBus;
     _userService = userService;
     _authenticationService = authenticationService;
 }

        public OpenIdServerConnector(IConfigSource config, IHttpServer server, string configName) :
                base(config, server, configName)
        {
            IConfig serverConfig = config.Configs[m_ConfigName];
            if (serverConfig == null)
                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));

            string authService = serverConfig.GetString("AuthenticationServiceModule",
                    String.Empty);
            string userService = serverConfig.GetString("UserAccountServiceModule",
                    String.Empty);

            if (authService == String.Empty || userService == String.Empty)
                throw new Exception("No AuthenticationServiceModule or no UserAccountServiceModule in config file for OpenId authentication");

            Object[] args = new Object[] { config };
            m_AuthenticationService = ServerUtils.LoadPlugin<IAuthenticationService>(authService, args);
            m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(userService, args);

            // Handler for OpenID user identity pages
            server.AddStreamHandler(new OpenIdStreamHandler("GET", "/users/", m_UserAccountService, m_AuthenticationService));
            // Handlers for the OpenID endpoint server
            server.AddStreamHandler(new OpenIdStreamHandler("POST", "/openid/server/", m_UserAccountService, m_AuthenticationService));
            server.AddStreamHandler(new OpenIdStreamHandler("GET", "/openid/server/", m_UserAccountService, m_AuthenticationService));

            m_log.Info("[OPENID]: OpenId service enabled");
        }