public void DoMigrations()
{
//if (String.IsNullOrEmpty(_config.SqlConnectionString.ProviderName) ||
// !_config.SqlConnectionString.ProviderName.Equals(SqlClient, StringComparison.OrdinalIgnoreCase))
//{
// return;
//}
var settingsManager = new DataSettingsManager();
try
{
//save settings
// var connectionString = "mongodb://" + userNameandPassword + model.MongoDBServerName + "/" + model.MongoDBDatabaseName;
var settings = new DataSettings
{
DataProvider = "mongodb",
DataConnectionString = " mongodb://localhost:27017/chatdb"
};
settingsManager.SaveSettings(settings);
var dataProviderInstance = new MongoDBDataProviderManager(settingsManager.LoadSettings()).LoadDataProvider();
dataProviderInstance.InitDatabase();
//now resolve installation service
var mongoDBDataProviderManager = new MongoDBDataProviderManager(settingsManager.LoadSettings());
var dataProviderInstall = mongoDBDataProviderManager.LoadDataProvider();
CreateIndexes();
InstallVersion();
}
catch (Exception exception)
{
}
}
public void TestInitialize()
{
var dataSettingsManager = new DataSettingsManager();
CommonHelper.BaseDirectory = System.AppDomain.CurrentDomain.BaseDirectory;
var dataProviderSettings = dataSettingsManager.LoadSettings();
MongoDBDataProviderManager baseDataProviderManager = new MongoDBDataProviderManager(dataProviderSettings);
IDataProvider dataProvider = baseDataProviderManager.LoadDataProvider();
dataProvider.InitDatabase();
_permissionRepository = new MongoDBRepository <Permission>();
_sqlpublishorderRepository = new MongoDBRepository <SqlPublishOrder>();
_menuRepository = new MongoDBRepository <Menu>();
_sqlpublishorderapprovalRepository = new MongoDBRepository <SqlPublishOrderApproval>();
_userRepository = new MongoDBRepository <User>();
_roleRepository = new MongoDBRepository <Role>();
var tempEventPublisher = new Mock <IEventPublisher>();
{
tempEventPublisher.Setup(x => x.Publish(It.IsAny <object>()));
_eventPublisher = tempEventPublisher.Object;
}
var cacheManager = new YimiNullCache();
//builder.Register(c => dataSettingsManager.LoadSettings()).As<DataSettings>();
//builder.Register(x => new MongoDBDataProviderManager(x.Resolve<DataSettings>())).As<BaseDataProviderManager>().InstancePerDependency();
//builder.Register(x => x.Resolve<BaseDataProviderManager>().LoadDataProvider()).As<IDataProvider>().InstancePerDependency();
//if (dataProviderSettings != null && dataProviderSettings.IsValid())
//{
// builder.Register<IMongoClient>(c => new MongoClient(dataProviderSettings.DataConnectionString)).SingleInstance();
// builder.Register<IMongoDBContext>(c => new MongoDBContext(dataProviderSettings.DataConnectionString)).InstancePerLifetimeScope();
//}
//else
//{
// builder.RegisterType<MongoDBContext>().As<IMongoDBContext>().InstancePerLifetimeScope();
//}
_userService = new UserService(_userRepository, _permissionRepository, _roleRepository, _sqlpublishorderRepository, _sqlpublishorderapprovalRepository, dataProvider, cacheManager, _eventPublisher);
_menuService = new MenuService(_menuRepository, _userRepository, _permissionRepository, _roleRepository, dataProvider, cacheManager, _eventPublisher);
_permissionService = new PermissionService(_permissionRepository, _roleRepository, _userRepository, dataProvider, cacheManager, _eventPublisher);
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
{
//HTTP context and other related stuff
builder.Register(c =>
//register FakeHttpContext when HttpContext is not available
HttpContext.Current != null ?
(new HttpContextWrapper(HttpContext.Current) as HttpContextBase) :
(new FakeHttpContext("~/") as HttpContextBase))
.As <HttpContextBase>()
.InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Request)
.As <HttpRequestBase>()
.InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Response)
.As <HttpResponseBase>()
.InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Server)
.As <HttpServerUtilityBase>()
.InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Session)
.As <HttpSessionStateBase>()
.InstancePerLifetimeScope();
//web helper
builder.RegisterType <WebHelper>().As <IWebHelper>().InstancePerLifetimeScope();
//user agent helper
builder.RegisterType <UserAgentHelper>().As <IUserAgentHelper>().InstancePerLifetimeScope();
//controllers
builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());
//data layer
var dataSettingsManager = new DataSettingsManager();
var dataProviderSettings = dataSettingsManager.LoadSettings();
builder.Register(c => dataSettingsManager.LoadSettings()).As <DataSettings>();
builder.Register(x => new MongoDBDataProviderManager(x.Resolve <DataSettings>())).As <BaseDataProviderManager>().InstancePerDependency();
builder.Register(x => x.Resolve <BaseDataProviderManager>().LoadDataProvider()).As <IDataProvider>().InstancePerDependency();
if (dataProviderSettings != null && dataProviderSettings.IsValid())
{
var mongoDBDataProviderManager = new MongoDBDataProviderManager(dataSettingsManager.LoadSettings());
var dataProvider = mongoDBDataProviderManager.LoadDataProvider();
builder.Register(c => new MongoClient(dataProviderSettings.DataConnectionString)).As(typeof(IMongoClient)).SingleInstance();
}
builder.RegisterGeneric(typeof(MongoDBRepository <>)).As(typeof(IRepository <>)).InstancePerLifetimeScope();
//plugins
builder.RegisterType <PluginFinder>().As <IPluginFinder>().InstancePerLifetimeScope();
builder.RegisterType <OfficialFeedManager>().As <IOfficialFeedManager>().InstancePerLifetimeScope();
//cache manager
if (config.RedisCachingEnabled)
{
builder.RegisterType <MemoryCacheManager>().As <ICacheManager>().Named <ICacheManager>("nop_cache_static").SingleInstance();
builder.RegisterType <RedisConnectionWrapper>().As <IRedisConnectionWrapper>().SingleInstance();
builder.RegisterType <RedisCacheManager>().As <ICacheManager>().SingleInstance();
}
else
{
builder.RegisterType <MemoryCacheManager>().As <ICacheManager>().SingleInstance();
}
if (config.RunOnAzureWebsites)
{
builder.RegisterType <AzureWebsitesMachineNameProvider>().As <IMachineNameProvider>().SingleInstance();
}
else
{
builder.RegisterType <DefaultMachineNameProvider>().As <IMachineNameProvider>().SingleInstance();
}
//work context
builder.RegisterType <WebWorkContext>().As <IWorkContext>().InstancePerLifetimeScope();
//store context
builder.RegisterType <WebStoreContext>().As <IStoreContext>().InstancePerLifetimeScope();
//services
builder.RegisterType <BackInStockSubscriptionService>().As <IBackInStockSubscriptionService>().InstancePerLifetimeScope();
builder.RegisterType <CategoryService>().As <ICategoryService>().InstancePerLifetimeScope();
builder.RegisterType <CompareProductsService>().As <ICompareProductsService>().InstancePerLifetimeScope();
builder.RegisterType <RecentlyViewedProductsService>().As <IRecentlyViewedProductsService>().InstancePerLifetimeScope();
builder.RegisterType <ManufacturerService>().As <IManufacturerService>().InstancePerLifetimeScope();
builder.RegisterType <PriceFormatter>().As <IPriceFormatter>().InstancePerLifetimeScope();
builder.RegisterType <ProductAttributeFormatter>().As <IProductAttributeFormatter>().InstancePerLifetimeScope();
builder.RegisterType <ProductAttributeParser>().As <IProductAttributeParser>().InstancePerLifetimeScope();
builder.RegisterType <ProductAttributeService>().As <IProductAttributeService>().InstancePerLifetimeScope();
builder.RegisterType <ProductService>().As <IProductService>().InstancePerLifetimeScope();
builder.RegisterType <CopyProductService>().As <ICopyProductService>().InstancePerLifetimeScope();
builder.RegisterType <SpecificationAttributeService>().As <ISpecificationAttributeService>().InstancePerLifetimeScope();
builder.RegisterType <ProductTemplateService>().As <IProductTemplateService>().InstancePerLifetimeScope();
builder.RegisterType <CategoryTemplateService>().As <ICategoryTemplateService>().InstancePerLifetimeScope();
builder.RegisterType <ManufacturerTemplateService>().As <IManufacturerTemplateService>().InstancePerLifetimeScope();
builder.RegisterType <TopicTemplateService>().As <ITopicTemplateService>().InstancePerLifetimeScope();
builder.RegisterType <ProductTagService>().As <IProductTagService>().InstancePerLifetimeScope();
builder.RegisterType <AddressAttributeFormatter>().As <IAddressAttributeFormatter>().InstancePerLifetimeScope();
builder.RegisterType <AddressAttributeParser>().As <IAddressAttributeParser>().InstancePerLifetimeScope();
builder.RegisterType <AddressAttributeService>().As <IAddressAttributeService>().InstancePerLifetimeScope();
builder.RegisterType <AddressService>().As <IAddressService>().InstancePerLifetimeScope();
builder.RegisterType <AffiliateService>().As <IAffiliateService>().InstancePerLifetimeScope();
builder.RegisterType <VendorService>().As <IVendorService>().InstancePerLifetimeScope();
builder.RegisterType <SearchTermService>().As <ISearchTermService>().InstancePerLifetimeScope();
builder.RegisterType <GenericAttributeService>().As <IGenericAttributeService>().InstancePerLifetimeScope();
builder.RegisterType <CustomerAttributeParser>().As <ICustomerAttributeParser>().InstancePerLifetimeScope();
builder.RegisterType <CustomerAttributeService>().As <ICustomerAttributeService>().InstancePerLifetimeScope();
builder.RegisterType <CustomerService>().As <ICustomerService>().InstancePerLifetimeScope();
builder.RegisterType <CustomerRegistrationService>().As <ICustomerRegistrationService>().InstancePerLifetimeScope();
builder.RegisterType <CustomerReportService>().As <ICustomerReportService>().InstancePerLifetimeScope();
builder.RegisterType <CustomerTagService>().As <ICustomerTagService>().InstancePerLifetimeScope();
builder.RegisterType <CustomerActionService>().As <ICustomerActionService>().InstancePerLifetimeScope();
builder.RegisterType <CustomerActionEventService>().As <ICustomerActionEventService>().InstancePerLifetimeScope();
builder.RegisterType <CustomerReminderService>().As <ICustomerReminderService>().InstancePerLifetimeScope();
builder.RegisterType <RewardPointsService>().As <IRewardPointsService>().InstancePerLifetimeScope();
builder.RegisterType <PermissionService>().As <IPermissionService>().InstancePerLifetimeScope();
builder.RegisterType <AclService>().As <IAclService>().InstancePerLifetimeScope();
builder.RegisterType <PriceCalculationService>().As <IPriceCalculationService>().InstancePerLifetimeScope();
builder.RegisterType <GeoLookupService>().As <IGeoLookupService>().InstancePerLifetimeScope();
builder.RegisterType <CountryService>().As <ICountryService>().InstancePerLifetimeScope();
builder.RegisterType <CurrencyService>().As <ICurrencyService>().InstancePerLifetimeScope();
builder.RegisterType <MeasureService>().As <IMeasureService>().InstancePerLifetimeScope();
builder.RegisterType <StateProvinceService>().As <IStateProvinceService>().InstancePerLifetimeScope();
builder.RegisterType <StoreService>().As <IStoreService>().InstancePerLifetimeScope();
builder.RegisterType <StoreMappingService>().As <IStoreMappingService>().InstancePerLifetimeScope();
builder.RegisterType <DiscountService>().As <IDiscountService>().InstancePerLifetimeScope();
//pass MemoryCacheManager as cacheManager (cache settings between requests)
if (config.RedisCachingEnabled)
{
builder.RegisterType <SettingService>().As <ISettingService>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
.InstancePerLifetimeScope();
builder.RegisterType <LocalizationService>().As <ILocalizationService>()
.WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
.InstancePerLifetimeScope();
}
else
{
builder.RegisterType <SettingService>().As <ISettingService>().InstancePerLifetimeScope();
builder.RegisterType <LocalizationService>().As <ILocalizationService>().InstancePerLifetimeScope();
}
builder.RegisterSource(new SettingsSource());
//pass MemoryCacheManager as cacheManager (cache locales between requests)
builder.RegisterType <LanguageService>().As <ILanguageService>().InstancePerLifetimeScope();
builder.RegisterType <DownloadService>().As <IDownloadService>().InstancePerLifetimeScope();
//picture service
var useAzureBlobStorage = !String.IsNullOrEmpty(config.AzureBlobStorageConnectionString);
if (useAzureBlobStorage)
{
//Windows Azure BLOB
builder.RegisterType <AzurePictureService>().As <IPictureService>().InstancePerLifetimeScope();
}
else
{
//standard file system
builder.RegisterType <PictureService>().As <IPictureService>().InstancePerLifetimeScope();
}
builder.RegisterType <MessageTemplateService>().As <IMessageTemplateService>().InstancePerLifetimeScope();
builder.RegisterType <QueuedEmailService>().As <IQueuedEmailService>().InstancePerLifetimeScope();
builder.RegisterType <NewsLetterSubscriptionService>().As <INewsLetterSubscriptionService>().InstancePerLifetimeScope();
builder.RegisterType <CampaignService>().As <ICampaignService>().InstancePerLifetimeScope();
builder.RegisterType <BannerService>().As <IBannerService>().InstancePerLifetimeScope();
builder.RegisterType <EmailAccountService>().As <IEmailAccountService>().InstancePerLifetimeScope();
builder.RegisterType <WorkflowMessageService>().As <IWorkflowMessageService>().InstancePerLifetimeScope();
builder.RegisterType <MessageTokenProvider>().As <IMessageTokenProvider>().InstancePerLifetimeScope();
builder.RegisterType <Tokenizer>().As <ITokenizer>().InstancePerLifetimeScope();
builder.RegisterType <EmailSender>().As <IEmailSender>().InstancePerLifetimeScope();
builder.RegisterType <CheckoutAttributeFormatter>().As <ICheckoutAttributeFormatter>().InstancePerLifetimeScope();
builder.RegisterType <CheckoutAttributeParser>().As <ICheckoutAttributeParser>().InstancePerLifetimeScope();
builder.RegisterType <CheckoutAttributeService>().As <ICheckoutAttributeService>().InstancePerLifetimeScope();
builder.RegisterType <GiftCardService>().As <IGiftCardService>().InstancePerLifetimeScope();
builder.RegisterType <OrderService>().As <IOrderService>().InstancePerLifetimeScope();
builder.RegisterType <OrderReportService>().As <IOrderReportService>().InstancePerLifetimeScope();
builder.RegisterType <OrderProcessingService>().As <IOrderProcessingService>().InstancePerLifetimeScope();
builder.RegisterType <OrderTotalCalculationService>().As <IOrderTotalCalculationService>().InstancePerLifetimeScope();
builder.RegisterType <ReturnRequestService>().As <IReturnRequestService>().InstancePerLifetimeScope();
builder.RegisterType <RewardPointsService>().As <IRewardPointsService>().InstancePerLifetimeScope();
builder.RegisterType <ShoppingCartService>().As <IShoppingCartService>().InstancePerLifetimeScope();
builder.RegisterType <PaymentService>().As <IPaymentService>().InstancePerLifetimeScope();
builder.RegisterType <EncryptionService>().As <IEncryptionService>().InstancePerLifetimeScope();
builder.RegisterType <FormsAuthenticationService>().As <IAuthenticationService>().InstancePerLifetimeScope();
builder.RegisterType <UrlRecordService>().As <IUrlRecordService>().InstancePerLifetimeScope();
builder.RegisterType <ShipmentService>().As <IShipmentService>().InstancePerLifetimeScope();
builder.RegisterType <ShippingService>().As <IShippingService>().InstancePerLifetimeScope();
builder.RegisterType <TaxCategoryService>().As <ITaxCategoryService>().InstancePerLifetimeScope();
builder.RegisterType <TaxService>().As <ITaxService>().InstancePerLifetimeScope();
builder.RegisterType <TaxCategoryService>().As <ITaxCategoryService>().InstancePerLifetimeScope();
builder.RegisterType <DefaultLogger>().As <ILogger>().InstancePerLifetimeScope();
builder.RegisterType <ContactUsService>().As <IContactUsService>().InstancePerLifetimeScope();
builder.RegisterType <CustomerActivityService>().As <ICustomerActivityService>().InstancePerLifetimeScope();
builder.RegisterType <ActivityKeywordsProvider>().As <IActivityKeywordsProvider>().InstancePerLifetimeScope();
bool databaseInstalled = DataSettingsHelper.DatabaseIsInstalled();
if (!databaseInstalled)
{
//installation service
builder.RegisterType <CodeFirstInstallationService>().As <IInstallationService>().InstancePerLifetimeScope();
}
else
{
builder.RegisterType <UpgradeService>().As <IUpgradeService>().InstancePerLifetimeScope();
}
builder.RegisterType <ForumService>().As <IForumService>().InstancePerLifetimeScope();
builder.RegisterType <PollService>().As <IPollService>().InstancePerLifetimeScope();
builder.RegisterType <BlogService>().As <IBlogService>().InstancePerLifetimeScope();
builder.RegisterType <WidgetService>().As <IWidgetService>().InstancePerLifetimeScope();
builder.RegisterType <TopicService>().As <ITopicService>().InstancePerLifetimeScope();
builder.RegisterType <NewsService>().As <INewsService>().InstancePerLifetimeScope();
builder.RegisterType <DateTimeHelper>().As <IDateTimeHelper>().InstancePerLifetimeScope();
builder.RegisterType <SitemapGenerator>().As <ISitemapGenerator>().InstancePerLifetimeScope();
builder.RegisterType <PageHeadBuilder>().As <IPageHeadBuilder>().InstancePerLifetimeScope();
builder.RegisterType <ScheduleTaskService>().As <IScheduleTaskService>().InstancePerLifetimeScope();
builder.RegisterType <ExportManager>().As <IExportManager>().InstancePerLifetimeScope();
builder.RegisterType <ImportManager>().As <IImportManager>().InstancePerLifetimeScope();
builder.RegisterType <PdfService>().As <IPdfService>().InstancePerLifetimeScope();
builder.RegisterType <ThemeProvider>().As <IThemeProvider>().InstancePerLifetimeScope();
builder.RegisterType <ThemeContext>().As <IThemeContext>().InstancePerLifetimeScope();
builder.RegisterType <ExternalAuthorizer>().As <IExternalAuthorizer>().InstancePerLifetimeScope();
builder.RegisterType <OpenAuthenticationService>().As <IOpenAuthenticationService>().InstancePerLifetimeScope();
builder.RegisterType <GoogleAnalyticsService>().As <IGoogleAnalyticsService>().InstancePerLifetimeScope();
builder.RegisterType <RoutePublisher>().As <IRoutePublisher>().SingleInstance();
//Register event consumers
var consumers = typeFinder.FindClassesOfType(typeof(IConsumer <>)).ToList();
foreach (var consumer in consumers)
{
builder.RegisterType(consumer)
.As(consumer.FindInterfaces((type, criteria) =>
{
var isMatch = type.IsGenericType && ((Type)criteria).IsAssignableFrom(type.GetGenericTypeDefinition());
return(isMatch);
}, typeof(IConsumer <>)))
.InstancePerLifetimeScope();
}
builder.RegisterType <EventPublisher>().As <IEventPublisher>().SingleInstance();
builder.RegisterType <SubscriptionService>().As <ISubscriptionService>().SingleInstance();
}
public ActionResult Index(InstallModel model)
{
if (DataSettingsHelper.DatabaseIsInstalled())
{
return(RedirectToRoute("HomePage"));
}
//set page timeout to 5 minutes
this.Server.ScriptTimeout = 300;
if (model.DatabaseConnectionString != null)
{
model.DatabaseConnectionString = model.DatabaseConnectionString.Trim();
}
string connectionString = "";
if (model.MongoDBConnectionInfo)
{
if (String.IsNullOrEmpty(model.DatabaseConnectionString))
{
ModelState.AddModelError("", _locService.GetResource("ConnectionStringRequired"));
}
else
{
connectionString = model.DatabaseConnectionString;
}
}
else
{
if (String.IsNullOrEmpty(model.MongoDBDatabaseName))
{
ModelState.AddModelError("", _locService.GetResource("DatabaseNameRequired"));
}
if (String.IsNullOrEmpty(model.MongoDBServerName))
{
ModelState.AddModelError("", _locService.GetResource("MongoDBNameRequired"));
}
string userNameandPassword = "";
if (!(String.IsNullOrEmpty(model.MongoDBUsername)))
{
userNameandPassword = model.MongoDBUsername + ":" + model.MongoDBPassword + "@";
}
connectionString = "mongodb://" + userNameandPassword + model.MongoDBServerName + "/" + model.MongoDBDatabaseName;
}
var webHelper = EngineContext.Current.Resolve <IWebHelper>();
//validate permissions
var dirsToCheck = FilePermissionHelper.GetDirectoriesWrite();
foreach (string dir in dirsToCheck)
{
if (!FilePermissionHelper.CheckPermissions(dir, false, true, true, false))
{
ModelState.AddModelError("", string.Format(_locService.GetResource("ConfigureDirectoryPermissions"), WindowsIdentity.GetCurrent().Name, dir));
}
}
var filesToCheck = FilePermissionHelper.GetFilesWrite();
foreach (string file in filesToCheck)
{
if (!FilePermissionHelper.CheckPermissions(file, false, true, true, true))
{
ModelState.AddModelError("", string.Format(_locService.GetResource("ConfigureFilePermissions"), WindowsIdentity.GetCurrent().Name, file));
}
}
if (ModelState.IsValid)
{
var settingsManager = new DataSettingsManager();
try
{
//save settings
var dataProvider = model.DataProvider;
var settings = new DataSettings
{
DataProvider = "mongodb",
DataConnectionString = connectionString
};
settingsManager.SaveSettings(settings);
var dataProviderInstance = EngineContext.Current.Resolve <BaseDataProviderManager>().LoadDataProvider();
dataProviderInstance.InitDatabase();
var dataSettingsManager = new DataSettingsManager();
var dataProviderSettings = dataSettingsManager.LoadSettings();
//now resolve installation service
var mongoDBDataProviderManager = new MongoDBDataProviderManager(dataSettingsManager.LoadSettings());
var dataProviderInstall = mongoDBDataProviderManager.LoadDataProvider();
var builder = new ContainerBuilder();
builder.Register(c => new MongoClient(dataProviderSettings.DataConnectionString)).As(typeof(IMongoClient)).SingleInstance();
builder.RegisterGeneric(typeof(MongoDBRepository <>)).As(typeof(IRepository <>)).InstancePerLifetimeScope();
builder.Update(EngineContext.Current.ContainerManager.Container);
var installationService = EngineContext.Current.Resolve <IInstallationService>();
installationService.InstallData(model.AdminEmail, model.AdminPassword, model.InstallSampleData);
//reset cache
DataSettingsHelper.ResetCache();
//install plugins
PluginManager.MarkAllPluginsAsUninstalled();
var pluginFinder = EngineContext.Current.Resolve <IPluginFinder>();
var plugins = pluginFinder.GetPlugins <IPlugin>(LoadPluginsMode.All)
.ToList()
.OrderBy(x => x.PluginDescriptor.Group)
.ThenBy(x => x.PluginDescriptor.DisplayOrder)
.ToList();
var pluginsIgnoredDuringInstallation = String.IsNullOrEmpty(_config.PluginsIgnoredDuringInstallation) ?
new List <string>() :
_config.PluginsIgnoredDuringInstallation
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
foreach (var plugin in plugins)
{
if (pluginsIgnoredDuringInstallation.Contains(plugin.PluginDescriptor.SystemName))
{
continue;
}
plugin.Install();
}
//register default permissions
var permissionProviders = new List <Type>();
permissionProviders.Add(typeof(StandardPermissionProvider));
foreach (var providerType in permissionProviders)
{
dynamic provider = Activator.CreateInstance(providerType);
EngineContext.Current.Resolve <IPermissionService>().InstallPermissions(provider);
}
//restart application
webHelper.RestartAppDomain();
//Redirect to home page
return(RedirectToRoute("HomePage"));
}
catch (Exception exception)
{
//reset cache
DataSettingsHelper.ResetCache();
//clear provider settings if something got wrong
settingsManager.SaveSettings(new DataSettings
{
DataProvider = null,
DataConnectionString = null
});
ModelState.AddModelError("", string.Format(_locService.GetResource("SetupFailed"), exception.Message));
}
}
//prepare language list
foreach (var lang in _locService.GetAvailableLanguages())
{
model.AvailableLanguages.Add(new SelectListItem
{
Value = Url.Action("ChangeLanguage", "Install", new { language = lang.Code }),
Text = lang.Name,
Selected = _locService.GetCurrentLanguage().Code == lang.Code,
});
}
return(View(model));
}
private static KernelBase SetupNinject(ChatConfiguration configuration)
{
var kernel = new StandardKernel(new[] { new FactoryModule() });
kernel.Bind <IRecentMessageCache>()
.To <NoopCache>()
.InSingletonScope();
//data layer
var dataSettingsManager = new DataSettingsManager();
var dataProviderSettings = dataSettingsManager.LoadSettings();
kernel.Bind <DataSettings>().ToMethod(context =>
{
return(dataSettingsManager.LoadSettings());
});
kernel.Bind <BaseDataProviderManager>().ToMethod(context =>
{
var recentDataSettings = context.Kernel.Get <DataSettings>();
return(new MongoDBDataProviderManager(recentDataSettings));
});
kernel.Bind <IDataProvider>().ToMethod(context =>
{
var recentBaseDataProviderManager = context.Kernel.Get <BaseDataProviderManager>();
return(recentBaseDataProviderManager.LoadDataProvider());
});
if (dataProviderSettings != null && dataProviderSettings.IsValid())
{
var mongoDBDataProviderManager = new MongoDBDataProviderManager(dataSettingsManager.LoadSettings());
var dataProvider = mongoDBDataProviderManager.LoadDataProvider();
kernel.Bind <IMongoClient>().ToMethod(context =>
{
return(new MongoClient(dataProviderSettings.DataConnectionString));
});
}
kernel.Bind(typeof(IRepository <>)).To(typeof(MongoDBRepository <>)).InSingletonScope();
kernel.Bind <IChatService>()
.To <ChatService>();
kernel.Bind <IDataProtector>()
.To <ChatDataProtection>();
kernel.Bind <ICookieAuthenticationProvider>()
.To <ChatFormsAuthenticationProvider>();
kernel.Bind <ILogger>()
.To <RealtimeLogger>();
//kernel.Bind<IUserIdProvider>()
// .To<ChatUserIdProvider>();
kernel.Bind <IChatConfiguration>()
.ToConstant(configuration);
// We're doing this manually since we want the chat repository to be shared
// between the chat service and the chat hub itself
kernel.Bind <Chat>()
.ToMethod(context =>
{
// var resourceProcessor = context.Kernel.Get<ContentProviderProcessor>();
var recentMessageCache = context.Kernel.Get <IRecentMessageCache>();
// var repository = context.Kernel.Get<IChatRepository>();
var cache = context.Kernel.Get <ICache>();
var logger = context.Kernel.Get <ILogger>();
var settings = context.Kernel.Get <ApplicationSettings>();
IRepository <ChatUser> repository = context.Kernel.Get <IRepository <ChatUser> >();
IRepository <ChatUserIdentity> chatUserIdentityRepository = context.Kernel.Get <IRepository <ChatUserIdentity> >();
IRepository <Attachment> attachmentRepository = context.Kernel.Get <IRepository <Attachment> >();
IRepository <ChatClient> chatClientRepository = context.Kernel.Get <IRepository <ChatClient> >();
IRepository <ChatMessage> chatMessagerepository = context.Kernel.Get <IRepository <ChatMessage> >();
IRepository <ChatRoom> chatRoomRepository = context.Kernel.Get <IRepository <ChatRoom> >();
IRepository <Notification> notificationRepository = context.Kernel.Get <IRepository <Notification> >();
IRepository <Settings> settingsRepository = context.Kernel.Get <IRepository <Settings> >();
var service = new ChatService(cache, repository, chatUserIdentityRepository, attachmentRepository, chatClientRepository
, chatMessagerepository, chatRoomRepository, notificationRepository, settingsRepository);
return(new Chat(repository, chatUserIdentityRepository, attachmentRepository, chatClientRepository
, chatMessagerepository, chatRoomRepository, notificationRepository, settingsRepository,
settings,
service,
cache,
logger
));
});
kernel.Bind <ICryptoService>()
.To <CryptoService>();
kernel.Bind <IJavaScriptMinifier>()
.To <AjaxMinMinifier>()
.InSingletonScope();
kernel.Bind <IMembershipService>()
.To <MembershipService>();
kernel.Bind <ApplicationSettings>()
.ToMethod(context =>
{
return(context.Kernel.Get <ISettingsManager>().Load());
});
kernel.Bind <ISettingsManager>()
.To <SettingsManager>();
kernel.Bind <IUserAuthenticator>()
.To <DefaultUserAuthenticator>();
kernel.Bind <ICache>()
.To <DefaultCache>()
.InSingletonScope();
//kernel.Bind<IChatNotificationService>()
// .To<ChatNotificationService>();
kernel.Bind <IKeyProvider>()
.To <SettingsKeyProvider>();
RegisterContentProviders(kernel);
var serializer = JsonSerializer.Create(new JsonSerializerSettings()
{
DateFormatHandling = DateFormatHandling.IsoDateFormat
});
kernel.Bind <JsonSerializer>()
.ToConstant(serializer);
return(kernel);
}
