public Test(){
var environment = CallContextServiceLocator.Locator.ServiceProvider.GetService(typeof(IApplicationEnvironment)) as IApplicationEnvironment;
var hostingEnvironment = new HostingEnvironment(environment);
var startup = new Startup(hostingEnvironment);
var testServer = TestServer.Create(x => startup.Configure(x, hostingEnvironment), startup.ConfigureServices);
client = testServer.CreateClient();
}
public TestBase()
{
if (ServiceProvider == null)
{
var services = new ServiceCollection();
// set up empty in-memory test db
services
.AddEntityFrameworkInMemoryDatabase()
.AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase().UseInternalServiceProvider(services.BuildServiceProvider()));
// add identity service
services.AddIdentity<ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores<AllReadyContext>();
var context = new DefaultHttpContext();
context.Features.Set<IHttpAuthenticationFeature>(new HttpAuthenticationFeature());
services.AddSingleton<IHttpContextAccessor>(h => new HttpContextAccessor { HttpContext = context });
// Setup hosting environment
IHostingEnvironment hostingEnvironment = new HostingEnvironment();
hostingEnvironment.EnvironmentName = "Development";
services.AddSingleton(x => hostingEnvironment);
// set up service provider for tests
ServiceProvider = services.BuildServiceProvider();
}
}
public HostingEngine(IServiceProvider fallbackServices)
{
_fallbackServices = fallbackServices ?? CallContextServiceLocator.Locator.ServiceProvider;
_appLifetime = new ApplicationLifetime();
_applicationEnvironment = _fallbackServices.GetRequiredService<IApplicationEnvironment>();
_hostingEnvironment = new HostingEnvironment(_applicationEnvironment);
_fallbackServices = new WrappingServiceProvider(_fallbackServices, _hostingEnvironment, _appLifetime);
}
public void OverridesEnvironmentFromConfig()
{
var env = new HostingEnvironment();
env.EnvironmentName = "SomeName";
env.Initialize("DummyApplication", Path.GetFullPath("."), new WebHostOptions(){ Environment = "NewName" });
Assert.Equal("NewName", env.EnvironmentName);
}
public void SetsFullPathToWwwroot()
{
var env = new HostingEnvironment();
env.Initialize("DummyApplication", Path.GetFullPath("."), new WebHostOptions(){ WebRoot = "testroot" });
Assert.Equal(Path.GetFullPath("."), env.ContentRootPath);
Assert.Equal(Path.GetFullPath("testroot"), env.WebRootPath);
Assert.IsAssignableFrom<PhysicalFileProvider>(env.ContentRootFileProvider);
Assert.IsAssignableFrom<PhysicalFileProvider>(env.WebRootFileProvider);
}
public void DefaultsToNullFileProvider()
{
var env = new HostingEnvironment();
env.Initialize("DummyApplication", Path.GetFullPath(Path.Combine("testroot", "wwwroot")), new WebHostOptions());
Assert.Equal(Path.GetFullPath(Path.Combine("testroot", "wwwroot")), env.ContentRootPath);
Assert.Null(env.WebRootPath);
Assert.IsAssignableFrom<PhysicalFileProvider>(env.ContentRootFileProvider);
Assert.IsAssignableFrom<NullFileProvider>(env.WebRootFileProvider);
}
public void StartupWithNoConfigureThrows()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddInstance<IFakeStartupCallback>(this);
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = "Boom" };
var loader = new StartupLoader(services, hostingEnv);
var type = loader.FindStartupType("Microsoft.AspNet.Hosting.Tests", diagnosticMessages);
var ex = Assert.Throws<InvalidOperationException>(() => loader.LoadMethods(type, diagnosticMessages));
Assert.Equal("A public method named 'ConfigureBoom' or 'Configure' could not be found in the 'Microsoft.AspNet.Hosting.Fakes.StartupBoom' type.", ex.Message);
}
public IISHost(HostingEnvironment env, ILogger log)
{
#region Preconditions
if (env == null)
throw new ArgumentNullException(nameof(env));
if (log == null)
throw new ArgumentNullException(nameof(log));
#endregion
this.env = env;
this.log = log;
}
public AllReadyDataAccessEF7Tests()
{
if (_serviceProvider == null)
{
var services = new ServiceCollection();
// Add EF (Full DB, not In-Memory)
services.AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase());
// Setup hosting environment
IHostingEnvironment hostingEnvironment = new HostingEnvironment();
hostingEnvironment.EnvironmentName = "Development";
services.AddSingleton(x => hostingEnvironment);
_serviceProvider = services.BuildServiceProvider();
}
}
public void StartupClassCanHandleConfigureServicesThatReturnsNull()
{
var serviceCollection = new ServiceCollection();
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = "WithNullConfigureServices" };
var loader = new StartupLoader(services, hostingEnv);
var type = loader.FindStartupType("Microsoft.AspNet.Hosting.Tests", diagnosticMessages);
var startup = loader.LoadMethods(type, diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(new ServiceCollection());
Assert.NotNull(app.ApplicationServices);
startup.ConfigureDelegate(app);
Assert.NotNull(app.ApplicationServices);
}
public void StartupClassMayHaveHostingServicesInjected()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddInstance<IFakeStartupCallback>(this);
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = "WithServices" };
var loader = new StartupLoader(services, hostingEnv);
var type = loader.FindStartupType("Microsoft.AspNet.Hosting.Tests", diagnosticMessages);
var startup = loader.LoadMethods(type, diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
startup.ConfigureDelegate(app);
Assert.Equal(2, _configurationMethodCalledList.Count);
}
public void StartupClassAddsConfigureServicesToApplicationServices(string environment)
{
var services = new ServiceCollection().BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = environment };
var loader = new StartupLoader(services, hostingEnv);
var type = loader.FindStartupType("Microsoft.AspNet.Hosting.Tests", diagnosticMessages);
var startup = loader.LoadMethods(type, diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(new ServiceCollection());
startup.ConfigureDelegate(app);
var options = app.ApplicationServices.GetRequiredService<IOptions<FakeOptions>>().Value;
Assert.NotNull(options);
Assert.True(options.Configured);
Assert.Equal(environment, options.Environment);
}
public void StartupWithTwoConfiguresThrows()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddInstance<IFakeStartupCallback>(this);
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = "TwoConfigures" };
var loader = new StartupLoader(services, hostingEnv);
var type = loader.FindStartupType("Microsoft.AspNet.Hosting.Tests", diagnosticMessages);
var ex = Assert.Throws<InvalidOperationException>(() => loader.LoadMethods(type, diagnosticMessages));
Assert.Equal("Having multiple overloads of method 'Configure' is not supported.", ex.Message);
}
public void StartupLoaderCanLoadByTypeWithEnvironment()
{
var serviceCollection = new ServiceCollection();
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = "No" };
var loader = new StartupLoader(services, hostingEnv);
var startup = loader.LoadMethods(typeof(TestStartup), diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
var ex = Assert.Throws<TargetInvocationException>(() => startup.ConfigureDelegate(app));
Assert.IsAssignableFrom(typeof(InvalidOperationException), ex.InnerException);
}
private void ConfigureApiServices(IServiceCollection services)
{
services.AddApiVersioning(options => options.VersionByQuery("api-version"));
services.AddSwaggerApiVersioning();
services.Configure <MvcJsonOptions>(
options =>
{
options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
options.SerializerSettings.Converters.Add(new StringEnumConverter {
CamelCaseText = true
});
options.SerializerSettings.Converters.Add(
new IsoDateTimeConverter
{
DateTimeFormat = "yyyy-MM-ddTHH:mm:ssZ",
DateTimeStyles = DateTimeStyles.AdjustToUniversal
});
});
services.AddSwaggerGen(
options =>
{
options.FilterOperations(
(op, ctx) =>
{
op.Responses["default"] = new Response
{
Description = "Error",
Schema = ctx.SchemaRegistry.GetOrRegister(typeof(ApiError))
};
op.OperationId = $"{op.Tags.First()}_{op.OperationId}";
});
options.MapType <TimeSpan>(
() => new Schema
{
Type = "string",
Format = "duration"
});
options.MapType <TimeSpan?>(
() => new Schema
{
Type = "string",
Format = "duration"
});
options.MapType <JToken>(() => new Schema());
options.DescribeAllEnumsAsStrings();
string xmlPath;
if (HostingEnvironment.IsDevelopment())
{
xmlPath = Path.Combine(HostingEnvironment.ContentRootPath, "bin/Debug/net461");
}
else
{
xmlPath = HostingEnvironment.ContentRootPath;
}
string xmlFile = Path.Combine(xmlPath, "Maestro.Web.xml");
if (File.Exists(xmlFile))
{
options.IncludeXmlComments(xmlFile);
}
options.AddSecurityDefinition(
"Bearer",
new ApiKeyScheme
{
Type = "apiKey",
In = "header",
Name = "Authorization"
});
options.FilterDocument(
(doc, ctx) =>
{
doc.Security = new List <IDictionary <string, IEnumerable <string> > >
{
new Dictionary <string, IEnumerable <string> >
{
["Bearer"] = Enumerable.Empty <string>()
}
};
});
});
}
public void StartupClassWithConfigureServicesShouldMakeServiceAvailableInConfigure()
{
var serviceCollection = new ServiceCollection();
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment { EnvironmentName = "WithConfigureServices" };
var loader = new StartupLoader(services, hostingEnv);
var type = loader.FindStartupType("Microsoft.AspNet.Hosting.Tests", diagnosticMessages);
var startup = loader.LoadMethods(type, diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
startup.ConfigureDelegate(app);
var foo = app.ApplicationServices.GetRequiredService<StartupWithConfigureServices.IFoo>();
Assert.True(foo.Invoked);
}
public void Shutdown()
{
HostingEnvironment.InitiateShutdown();
}
public ILifetimeScope CreateContainer(ShellSettings settings, ShellBlueprint blueprint)
{
var intermediateScope = _lifetimeScope.BeginLifetimeScope(
builder => {
foreach (var item in blueprint.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type)))
{
var registration = RegisterType(builder, item)
.Keyed <IModule>(item.Type)
.InstancePerDependency();
foreach (var parameter in item.Parameters)
{
registration = registration
.WithParameter(parameter.Name, parameter.Value)
.WithProperty(parameter.Name, parameter.Value);
}
}
});
return(intermediateScope.BeginLifetimeScope(
"shell",
builder => {
var dynamicProxyContext = new DynamicProxyContext();
builder.Register(ctx => dynamicProxyContext);
builder.Register(ctx => settings);
builder.Register(ctx => blueprint.Descriptor);
builder.Register(ctx => blueprint);
var moduleIndex = intermediateScope.Resolve <IIndex <Type, IModule> >();
foreach (var item in blueprint.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type)))
{
builder.RegisterModule(moduleIndex[item.Type]);
}
foreach (var item in blueprint.Dependencies.Where(t => typeof(IDependency).IsAssignableFrom(t.Type)))
{
var registration = RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.InstancePerLifetimeScope();
foreach (var interfaceType in item.Type.GetInterfaces()
.Where(itf => typeof(IDependency).IsAssignableFrom(itf) &&
!typeof(IEventHandler).IsAssignableFrom(itf)))
{
registration = registration.As(interfaceType).AsSelf();
if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType))
{
registration = registration.InstancePerMatchingLifetimeScope("shell");
}
else if (typeof(IUnitOfWorkDependency).IsAssignableFrom(interfaceType))
{
registration = registration.InstancePerMatchingLifetimeScope("work");
}
else if (typeof(ITransientDependency).IsAssignableFrom(interfaceType))
{
registration = registration.InstancePerDependency();
}
}
if (typeof(IEventHandler).IsAssignableFrom(item.Type))
{
var interfaces = item.Type.GetInterfaces();
foreach (var interfaceType in interfaces)
{
// register named instance for each interface, for efficient filtering inside event bus
// IEventHandler derived classes only
if (interfaceType.GetInterface(typeof(IEventHandler).Name) != null)
{
registration = registration.Named <IEventHandler>(interfaceType.Name);
}
}
}
foreach (var parameter in item.Parameters)
{
registration = registration
.WithParameter(parameter.Name, parameter.Value)
.WithProperty(parameter.Name, parameter.Value);
}
}
foreach (var item in blueprint.Controllers)
{
var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
var serviceKeyType = item.Type;
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed <IController>(serviceKeyName)
.Keyed <IController>(serviceKeyType)
.WithMetadata("ControllerType", item.Type)
.InstancePerDependency()
;
}
foreach (var item in blueprint.HttpControllers)
{
var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
var serviceKeyType = item.Type;
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed <IHttpController>(serviceKeyName)
.Keyed <IHttpController>(serviceKeyType)
.WithMetadata("ControllerType", item.Type)
.InstancePerDependency();
}
// Register code-only registrations specific to a shell
_shellContainerRegistrations.Registrations(builder);
var optionalShellByNameConfig = HostingEnvironment.MapPath("~/Config/Sites." + settings.Name + ".config");
if (File.Exists(optionalShellByNameConfig))
{
builder.RegisterModule(new ConfigurationSettingsReader(ConfigurationSettingsReaderConstants.DefaultSectionName, optionalShellByNameConfig));
}
else
{
var optionalShellConfig = HostingEnvironment.MapPath("~/Config/Sites.config");
if (File.Exists(optionalShellConfig))
{
builder.RegisterModule(new ConfigurationSettingsReader(ConfigurationSettingsReaderConstants.DefaultSectionName, optionalShellConfig));
}
}
var optionalComponentsConfig = HostingEnvironment.MapPath("~/Config/HostComponents.config");
if (File.Exists(optionalComponentsConfig))
{
builder.RegisterModule(new HostComponentsConfigModule(optionalComponentsConfig));
}
}));
}
private bool CKEditorIngoThaWatchaIsInstalled()
{
return(File.Exists(HostingEnvironment.MapPath("~/Providers/HtmlEditorProviders/CKEditor/ckeditor.js")));
}
/// <summary>
/// Gets the full path of InstalledPlugins.txt file
/// </summary>
/// <returns></returns>
private static string GetInstalledPluginsFilePath()
{
var filePath = HostingEnvironment.MapPath(_installedPluginsFilePath);
return(filePath);
}
protected override void Load(ContainerBuilder builder)
{
var configuration = new ConfigurationService();
builder.RegisterInstance(configuration)
.AsSelf()
.As <PoliteCaptcha.IConfigurationSource>();
builder.Register(c => configuration.Current)
.AsSelf()
.As <IAppConfiguration>();
builder.RegisterInstance(LuceneCommon.GetDirectory(configuration.Current.LuceneIndexLocation))
.As <Lucene.Net.Store.Directory>()
.SingleInstance();
ConfigureSearch(builder, configuration);
if (!string.IsNullOrEmpty(configuration.Current.AzureStorageConnectionString))
{
builder.RegisterInstance(new TableErrorLog(configuration.Current.AzureStorageConnectionString))
.As <ErrorLog>()
.SingleInstance();
}
else
{
builder.RegisterInstance(new SqlErrorLog(configuration.Current.SqlConnectionString))
.As <ErrorLog>()
.SingleInstance();
}
builder.RegisterType <HttpContextCacheService>()
.AsSelf()
.As <ICacheService>()
.InstancePerLifetimeScope();
builder.RegisterType <ContentService>()
.AsSelf()
.As <IContentService>()
.SingleInstance();
builder.Register(c => new EntitiesContext(configuration.Current.SqlConnectionString, readOnly: configuration.Current.ReadOnlyMode))
.AsSelf()
.As <IEntitiesContext>()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <User> >()
.AsSelf()
.As <IEntityRepository <User> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <CuratedFeed> >()
.AsSelf()
.As <IEntityRepository <CuratedFeed> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <CuratedPackage> >()
.AsSelf()
.As <IEntityRepository <CuratedPackage> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageRegistration> >()
.AsSelf()
.As <IEntityRepository <PackageRegistration> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <Package> >()
.AsSelf()
.As <IEntityRepository <Package> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageDependency> >()
.AsSelf()
.As <IEntityRepository <PackageDependency> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageStatistics> >()
.AsSelf()
.As <IEntityRepository <PackageStatistics> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <Credential> >()
.AsSelf()
.As <IEntityRepository <Credential> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageOwnerRequest> >()
.AsSelf()
.As <IEntityRepository <PackageOwnerRequest> >()
.InstancePerLifetimeScope();
builder.RegisterType <CuratedFeedService>()
.AsSelf()
.As <ICuratedFeedService>()
.InstancePerLifetimeScope();
builder.RegisterType <UserService>()
.AsSelf()
.As <IUserService>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageService>()
.AsSelf()
.As <IPackageService>()
.InstancePerLifetimeScope();
builder.RegisterType <EditPackageService>()
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterType <FormsAuthenticationService>()
.As <IFormsAuthenticationService>()
.InstancePerLifetimeScope();
builder.RegisterType <CookieTempDataProvider>()
.As <ITempDataProvider>()
.InstancePerLifetimeScope();
builder.RegisterType <NuGetExeDownloaderService>()
.AsSelf()
.As <INuGetExeDownloaderService>()
.InstancePerLifetimeScope();
builder.RegisterType <StatusService>()
.AsSelf()
.As <IStatusService>()
.InstancePerLifetimeScope();
var mailSenderThunk = new Lazy <IMailSender>(
() =>
{
var settings = configuration;
if (settings.Current.SmtpUri != null && settings.Current.SmtpUri.IsAbsoluteUri)
{
var smtpUri = new SmtpUri(settings.Current.SmtpUri);
var mailSenderConfiguration = new MailSenderConfiguration
{
DeliveryMethod = SmtpDeliveryMethod.Network,
Host = smtpUri.Host,
Port = smtpUri.Port,
EnableSsl = smtpUri.Secure
};
if (!string.IsNullOrWhiteSpace(smtpUri.UserName))
{
mailSenderConfiguration.UseDefaultCredentials = false;
mailSenderConfiguration.Credentials = new NetworkCredential(
smtpUri.UserName,
smtpUri.Password);
}
return(new MailSender(mailSenderConfiguration));
}
else
{
var mailSenderConfiguration = new MailSenderConfiguration
{
DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
PickupDirectoryLocation = HostingEnvironment.MapPath("~/App_Data/Mail")
};
return(new MailSender(mailSenderConfiguration));
}
});
builder.Register(c => mailSenderThunk.Value)
.AsSelf()
.As <IMailSender>()
.InstancePerLifetimeScope();
builder.RegisterType <MessageService>()
.AsSelf()
.As <IMessageService>()
.InstancePerLifetimeScope();
builder.Register(c => HttpContext.Current.User)
.AsSelf()
.As <IPrincipal>()
.InstancePerLifetimeScope();
switch (configuration.Current.StorageType)
{
case StorageType.FileSystem:
case StorageType.NotSpecified:
ConfigureForLocalFileSystem(builder);
break;
case StorageType.AzureStorage:
ConfigureForAzureStorage(builder, configuration);
break;
}
builder.RegisterType <FileSystemService>()
.AsSelf()
.As <IFileSystemService>()
.SingleInstance();
builder.RegisterType <PackageFileService>()
.AsSelf()
.As <IPackageFileService>()
.InstancePerLifetimeScope();
builder.RegisterType <UploadFileService>()
.AsSelf()
.As <IUploadFileService>()
.InstancePerLifetimeScope();
// todo: bind all package curators by convention
builder.RegisterType <WebMatrixPackageCurator>()
.AsSelf()
.As <IAutomaticPackageCurator>()
.InstancePerLifetimeScope();
builder.RegisterType <Windows8PackageCurator>()
.AsSelf()
.As <IAutomaticPackageCurator>()
.InstancePerLifetimeScope();
// todo: bind all commands by convention
builder.RegisterType <AutomaticallyCuratePackageCommand>()
.AsSelf()
.As <IAutomaticallyCuratePackageCommand>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageIdsQuery>()
.AsSelf()
.As <IPackageIdsQuery>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageVersionsQuery>()
.AsSelf()
.As <IPackageVersionsQuery>()
.InstancePerLifetimeScope();
builder.RegisterType <DiagnosticsService>()
.AsSelf()
.As <IDiagnosticsService>()
.SingleInstance();
}
private bool CKEditorDnnConnectIsInstalled()
{
return(File.Exists(HostingEnvironment.MapPath("~/Providers/HtmlEditorProviders/DNNConnect.CKE/js/ckeditor/4.5.3/ckeditor.js")));
}
static WelcomeNewMemberAdaptiveCard()
{
var cardJsonFilePath = HostingEnvironment.MapPath("~/Helpers/AdaptiveCards/WelcomeNewMemberAdaptiveCard.json");
CardTemplate = File.ReadAllText(cardJsonFilePath);
}
public ResponseAction PostTwitter(PostToTwitterViewModel message)
{
ResponseAction rsp = new ResponseAction();
rsp.Success = true;
bool trysended = false;
List <TwitterAccountPart> TwitterAccountSettings = Twitter_GetAccessToken(message.AccountList);
var pcr = _providerConfigurationService.Get("Twitter");
foreach (TwitterAccountPart Faccount in TwitterAccountSettings)
{
try {
trysended = true;
OAuthTokens accesstoken = new OAuthTokens()
{
AccessToken = Faccount.UserToken,
AccessTokenSecret = Faccount.UserTokenSecret,
ConsumerKey = pcr.ProviderIdKey,
ConsumerSecret = pcr.ProviderSecret
};
TwitterResponse <TwitterStatus> response;
string realmessage = message.Message;
if (!string.IsNullOrEmpty(message.Link))
{
realmessage += " " + message.Link;
}
if (string.IsNullOrEmpty(message.Picture))
{
response = TwitterStatus.Update(accesstoken, realmessage.Trim());
}
else
{
var mediaPath = HostingEnvironment.IsHosted
? HostingEnvironment.MapPath("~/Media/") ?? ""
: Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Media");
string physicalPath = mediaPath + _shellsettings.Name + "\\" + message.Picture;
byte[] photo = System.IO.File.ReadAllBytes(physicalPath);
response = TwitterStatus.UpdateWithMedia(accesstoken, realmessage.Trim(), photo, new StatusUpdateOptions()
{
UseSSL = true, APIBaseAddress = "http://api.twitter.com/1.1/"
});
}
if (response.Result != RequestResult.Success)
{
if (response.Content != null)
{
Logger.Error("response.Content:" + response.Content);
}
rsp.Success = false;
if (response.ErrorMessage != null)
{
Logger.Error("response.ErrorMessage:" + response.ErrorMessage);
_notifier.Add(NotifyType.Error, T("Can't post on twitter: {0} {1}", Faccount.DisplayAs, response.ErrorMessage));
}
else
{
var serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
var jsondict = serializer.Deserialize <Dictionary <string, object> >(response.Content);
ArrayList errors = (ArrayList)jsondict["errors"];
foreach (System.Collections.Generic.Dictionary <string, object> error in errors)
{
string errormsg = "";
foreach (var errordict in error)
{
errormsg += " " + errordict.Key.ToString() + ":" + errordict.Value.ToString();
}
_notifier.Add(NotifyType.Error, T("Can't post on twitter: {0} {1}", Faccount.DisplayAs, errormsg));
}
}
}
} catch (Exception ex) {
Logger.Error("Twitter Posting Error Message::" + ex.Message);
rsp.Success = false;
rsp.Message = "Twitter Posting Error Message: " + ex.Message;
_notifier.Add(NotifyType.Error, T("Twitter Posting {0} Error Message: {1}", Faccount.DisplayAs, ex.Message));
}
}
if (trysended && rsp.Success)
{
_notifier.Add(NotifyType.Information, T("Twitter posted"));
}
return(rsp);
}
private string GetRootPath(string path)
{
return(Path.IsPathRooted(path) ? path : HostingEnvironment.MapPath(path));
}
private static FileStream OpenUserDatabase()
{
return(new FileStream(HostingEnvironment.MapPath("~/userdb.xml"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None));
}
public static string Get(string tenant, string key)
{
string configFile = HostingEnvironment.MapPath($"~/Tenants/{tenant}/Configs/Frapid.config");
return(!File.Exists(configFile) ? string.Empty : ConfigurationManager.ReadConfigurationValue(configFile, key));
}
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();
}
//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,
});
}
model.DisableSqlCompact = _config.UseFastInstallationService;
model.DisableSampleDataOption = _config.DisableSampleDataDuringInstallation;
//SQL Server
if (model.DataProvider.Equals("sqlserver", StringComparison.InvariantCultureIgnoreCase))
{
if (model.SqlConnectionInfo.Equals("sqlconnectioninfo_raw", StringComparison.InvariantCultureIgnoreCase))
{
//raw connection string
if (string.IsNullOrEmpty(model.DatabaseConnectionString))
{
ModelState.AddModelError("", _locService.GetResource("ConnectionStringRequired"));
}
try
{
//try to create connection string
new SqlConnectionStringBuilder(model.DatabaseConnectionString);
}
catch
{
ModelState.AddModelError("", _locService.GetResource("ConnectionStringWrongFormat"));
}
}
else
{
//values
if (string.IsNullOrEmpty(model.SqlServerName))
{
ModelState.AddModelError("", _locService.GetResource("SqlServerNameRequired"));
}
if (string.IsNullOrEmpty(model.SqlDatabaseName))
{
ModelState.AddModelError("", _locService.GetResource("DatabaseNameRequired"));
}
//authentication type
if (model.SqlAuthenticationType.Equals("sqlauthentication", StringComparison.InvariantCultureIgnoreCase))
{
//SQL authentication
if (string.IsNullOrEmpty(model.SqlServerUsername))
{
ModelState.AddModelError("", _locService.GetResource("SqlServerUsernameRequired"));
}
if (string.IsNullOrEmpty(model.SqlServerPassword))
{
ModelState.AddModelError("", _locService.GetResource("SqlServerPasswordRequired"));
}
}
}
}
//Consider granting access rights to the resource to the ASP.NET request identity.
//ASP.NET has a base process identity
//(typically {MACHINE}\ASPNET on IIS 5 or Network Service on IIS 6 and IIS 7,
//and the configured application pool identity on IIS 7.5) that is used if the application is not impersonating.
//If the application is impersonating via <identity impersonate="true"/>,
//the identity will be the anonymous user (typically IUSR_MACHINENAME) or the authenticated request user.
var webHelper = EngineContext.Current.Resolve <IWebHelper>();
//validate permissions
var dirsToCheck = FilePermissionHelper.GetDirectoriesWrite(webHelper);
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(webHelper);
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
{
string connectionString;
if (model.DataProvider.Equals("sqlserver", StringComparison.InvariantCultureIgnoreCase))
{
//SQL Server
if (model.SqlConnectionInfo.Equals("sqlconnectioninfo_raw", StringComparison.InvariantCultureIgnoreCase))
{
//raw connection string
//we know that MARS option is required when using Entity Framework
//let's ensure that it's specified
var sqlCsb = new SqlConnectionStringBuilder(model.DatabaseConnectionString);
if (this.UseMars)
{
sqlCsb.MultipleActiveResultSets = true;
}
connectionString = sqlCsb.ToString();
}
else
{
//values
connectionString = CreateConnectionString(model.SqlAuthenticationType == "windowsauthentication",
model.SqlServerName, model.SqlDatabaseName,
model.SqlServerUsername, model.SqlServerPassword);
}
if (model.SqlServerCreateDatabase)
{
if (!SqlServerDatabaseExists(connectionString))
{
//create database
var collation = model.UseCustomCollation ? model.Collation : "";
var errorCreatingDatabase = CreateDatabase(connectionString, collation);
if (!String.IsNullOrEmpty(errorCreatingDatabase))
{
throw new Exception(errorCreatingDatabase);
}
//Database cannot be created sometimes. Weird! Seems to be Entity Framework issue
//that's just wait 5 seconds (3 seconds is not enough for some reasons)
Thread.Sleep(5000);
}
}
else
{
//check whether database exists
if (!SqlServerDatabaseExists(connectionString))
{
throw new Exception(_locService.GetResource("DatabaseNotExists"));
}
}
}
else
{
//SQL CE
string databaseFileName = "Nop.Db.sdf";
string databasePath = @"|DataDirectory|\" + databaseFileName;
connectionString = "Data Source=" + databasePath + ";Persist Security Info=False";
//drop database if exists
string databaseFullPath = HostingEnvironment.MapPath("~/App_Data/") + databaseFileName;
if (System.IO.File.Exists(databaseFullPath))
{
System.IO.File.Delete(databaseFullPath);
}
}
//save settings
var dataProvider = model.DataProvider;
var settings = new DataSettings
{
DataProvider = dataProvider,
DataConnectionString = connectionString
};
settingsManager.SaveSettings(settings);
//init data provider
var dataProviderInstance = EngineContext.Current.Resolve <BaseDataProviderManager>().LoadDataProvider();
dataProviderInstance.InitDatabase();
//now resolve installation service
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 = EngineContext.Current.Resolve<ITypeFinder>().FindClassesOfType<IPermissionProvider>();
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));
}
}
return(View(model));
}
public virtual string MapPath(string virtualPath)
{
return(HostingEnvironment.MapPath(virtualPath));
}
/// <summary>
/// Initialize
/// </summary>
public static void Initialize()
{
return;
using (new WriteLockDisposable(Locker))
{
// TODO: Add verbose exception handling / raising here since this is happening on app startup and could
// prevent app from starting altogether
var pluginFolder = new DirectoryInfo(HostingEnvironment.MapPath(_pluginsPath));
_shadowCopyFolder = new DirectoryInfo(HostingEnvironment.MapPath(_shadowCopyPath));
var referencedPlugins = new List <PluginDescriptor>();
var incompatiblePlugins = new List <string>();
_clearShadowDirectoryOnStartup = !String.IsNullOrEmpty(ConfigurationManager.AppSettings["ClearPluginsShadowDirectoryOnStartup"]) &&
Convert.ToBoolean(ConfigurationManager.AppSettings["ClearPluginsShadowDirectoryOnStartup"]);
try
{
var installedPluginSystemNames = PluginFileParser.ParseInstalledPluginsFile(GetInstalledPluginsFilePath());
Debug.WriteLine("Creating shadow copy folder and querying for dlls");
//ensure folders are created
Directory.CreateDirectory(pluginFolder.FullName);
Directory.CreateDirectory(_shadowCopyFolder.FullName);
//get list of all files in bin
var binFiles = _shadowCopyFolder.GetFiles("*", SearchOption.AllDirectories);
if (_clearShadowDirectoryOnStartup)
{
//clear out shadow copied plugins
foreach (var f in binFiles)
{
Debug.WriteLine("Deleting " + f.Name);
try
{
File.Delete(f.FullName);
}
catch (Exception exc)
{
Debug.WriteLine("Error deleting file " + f.Name + ". Exception: " + exc);
}
}
}
//load description files
foreach (var dfd in GetDescriptionFilesAndDescriptors(pluginFolder))
{
var descriptionFile = dfd.Key;
var pluginDescriptor = dfd.Value;
//ensure that version of plugin is valid
if (!pluginDescriptor.SupportedVersions.Contains(OceanVersion.CurrentVersion, StringComparer.InvariantCultureIgnoreCase))
{
incompatiblePlugins.Add(pluginDescriptor.SystemName);
continue;
}
//some validation
if (String.IsNullOrWhiteSpace(pluginDescriptor.SystemName))
{
throw new Exception(string.Format("A plugin '{0}' has no system name. Try assigning the plugin a unique name and recompiling.", descriptionFile.FullName));
}
if (referencedPlugins.Contains(pluginDescriptor))
{
throw new Exception(string.Format("A plugin with '{0}' system name is already defined", pluginDescriptor.SystemName));
}
//set 'Installed' property
pluginDescriptor.Installed = installedPluginSystemNames
.ToList()
.Where(x => x.Equals(pluginDescriptor.SystemName, StringComparison.InvariantCultureIgnoreCase))
.FirstOrDefault() != null;
try
{
//get list of all DLLs in plugins (not in bin!)
var pluginFiles = descriptionFile.Directory.GetFiles("*.dll", SearchOption.AllDirectories)
//just make sure we're not registering shadow copied plugins
.Where(x => !binFiles.Select(q => q.FullName).Contains(x.FullName))
.Where(x => IsPackagePluginFolder(x.Directory))
.ToList();
//other plugin description info
var mainPluginFile = pluginFiles.Where(x => x.Name.Equals(pluginDescriptor.PluginFileName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
pluginDescriptor.OriginalAssemblyFile = mainPluginFile;
//shadow copy main plugin file
pluginDescriptor.ReferencedAssembly = PerformFileDeploy(mainPluginFile);
//load all other referenced assemblies now
foreach (var plugin in pluginFiles
.Where(x => !x.Name.Equals(mainPluginFile.Name, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !IsAlreadyLoaded(x)))
{
PerformFileDeploy(plugin);
}
//init plugin type (only one plugin per assembly is allowed)
foreach (var t in pluginDescriptor.ReferencedAssembly.GetTypes())
{
if (typeof(IPlugin).IsAssignableFrom(t))
{
if (!t.IsInterface)
{
if (t.IsClass && !t.IsAbstract)
{
pluginDescriptor.PluginType = t;
break;
}
}
}
}
referencedPlugins.Add(pluginDescriptor);
}
catch (ReflectionTypeLoadException ex)
{
var msg = string.Empty;
foreach (var e in ex.LoaderExceptions)
{
msg += e.Message + Environment.NewLine;
}
var fail = new Exception(msg, ex);
Debug.WriteLine(fail.Message, fail);
throw fail;
}
}
}
catch (Exception ex)
{
var msg = string.Empty;
for (var e = ex; e != null; e = e.InnerException)
{
msg += e.Message + Environment.NewLine;
}
var fail = new Exception(msg, ex);
Debug.WriteLine(fail.Message, fail);
throw fail;
}
ReferencedPlugins = referencedPlugins;
IncompatiblePlugins = incompatiblePlugins;
}
}
/// <summary>Registers the type mappings with the Unity container.</summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to
/// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
public static IDependencyResolver RegisterTypes(IUnityContainer container)
{
IDependencyResolver resolver = container.Initialize <UnityConfig, WebAPICurrentIdentity>(string.Empty, string.Empty,
WebApiConfiguration.ServiceBusConnectionString, HostingEnvironment.MapPath(WebApiConfiguration.MESSAGE_CONFIGURATION_FILE_PATH),
WebApiConfiguration.CustomInstanceName,
WebApiConfiguration.AutoDeleteOnIdle, WebApiConfiguration.DefaultMessageTimeToLive, WebApiConfiguration.LockDuration,
WebApiConfiguration.MaxDeliveryCount);
IDataUnitOfWork unitOfWork = (IDataUnitOfWork)resolver.BeginScope().GetService(typeof(IDataUnitOfWork));
Security.ISecurity security = (Security.ISecurity)resolver.BeginScope().GetService(typeof(Security.ISecurity));
container.RegisterInstance(AutoMapperConfig.RegisterMappings(unitOfWork, security));
return(resolver);
}
private Site ConfigureSite(IApp app)
{
#region Preconditions
if (app == null)
throw new ArgumentNullException(nameof(app));
#endregion
var physicalPath = GetAppPath(app);
var site = serverManager.Sites.CreateElement();
site.Id = app.Id;
site.Name = app.Name.ToString(); // id?
site.ServerAutoStart = true; // Start the server automatically
site.LogFile.Enabled = false; // Disable site logging
var siteApp = site.Applications.CreateElement(); // Create a site app
siteApp.Path = "/"; // Site the root path
siteApp.ApplicationPoolName = app.Name.ToString(); // Site the pool name
site.Applications.Add(siteApp);
// Create a virtual directory
var virtualDirectory = siteApp.VirtualDirectories.CreateElement();
virtualDirectory.Path = "/";
virtualDirectory.PhysicalPath = physicalPath.ToString();
siteApp.VirtualDirectories.Add(virtualDirectory);
// env
// {
// listeners: [ "80/http", "http://carbon.com:8080" ]
// }
JsonObject env = null;
if (app is App)
{
env = ((App)app).Env;
}
if (env == null)
{
Console.WriteLine("no env");
}
if (env != null && env.ContainsKey("listeners"))
{
foreach (var listener in (JsonArray)env["listeners"])
{
var b = new WebBinding(Listener.Parse(listener));
var binding = site.Bindings.CreateElement();
binding.Protocol = b.Protocol;
binding.BindingInformation = b.ToString();
site.Bindings.Add(binding);
}
}
else
{
Console.WriteLine("no listeners");
}
return site;
}
protected override void Initialize()
{
bool enableLocalization = true;
string absoluteFileName = HostingEnvironment.MapPath("~/Mvc.sitemap");
TimeSpan absoluteCacheExpiration = TimeSpan.FromMinutes(5);
bool visibilityAffectsDescendants = true;
bool useTitleIfDescriptionNotProvided = true;
bool securityTrimmingEnabled = false;
string[] includeAssembliesForScan = new string[] { "MvcDemos" };
var currentAssembly = this.GetType().Assembly;
var siteMapProviderAssembly = typeof(SiteMaps).Assembly;
var allAssemblies = new Assembly[] { currentAssembly, siteMapProviderAssembly };
var excludeTypes = new Type[] {
// Use this array to add types you wish to explicitly exclude from convention-based
// auto-registration. By default all types that either match I[TypeName] = [TypeName] or
// I[TypeName] = [TypeName]Adapter will be automatically wired up as long as they don't
// have the [ExcludeFromAutoRegistrationAttribute].
//
// If you want to override a type that follows the convention, you should add the name
// of either the implementation name or the interface that it inherits to this list and
// add your manual registration code below. This will prevent duplicate registrations
// of the types from occurring.
// Example:
// typeof(SiteMap),
// typeof(SiteMapNodeVisibilityProviderStrategy)
};
var multipleImplementationTypes = new Type[] {
typeof(ISiteMapNodeUrlResolver),
typeof(ISiteMapNodeVisibilityProvider),
typeof(IDynamicNodeProvider)
};
// Matching type name (I[TypeName] = [TypeName]) or matching type name + suffix Adapter (I[TypeName] = [TypeName]Adapter)
// and not decorated with the [ExcludeFromAutoRegistrationAttribute].
CommonConventions.RegisterDefaultConventions(
(interfaceType, implementationType) => this.Container.RegisterType(interfaceType, implementationType, new ContainerControlledLifetimeManager()),
new Assembly[] { siteMapProviderAssembly },
allAssemblies,
excludeTypes,
string.Empty);
// Multiple implementations of strategy based extension points (and not decorated with [ExcludeFromAutoRegistrationAttribute]).
CommonConventions.RegisterAllImplementationsOfInterface(
(interfaceType, implementationType) => this.Container.RegisterType(interfaceType, implementationType, implementationType.Name, new ContainerControlledLifetimeManager()),
multipleImplementationTypes,
allAssemblies,
excludeTypes,
string.Empty);
// TODO: Find a better way to inject an array constructor
// Url Resolvers
this.Container.RegisterType <ISiteMapNodeUrlResolverStrategy, SiteMapNodeUrlResolverStrategy>(new InjectionConstructor(
new ResolvedArrayParameter <ISiteMapNodeUrlResolver>(this.Container.ResolveAll <ISiteMapNodeUrlResolver>().ToArray())
));
// Visibility Providers
this.Container.RegisterType <ISiteMapNodeVisibilityProviderStrategy, SiteMapNodeVisibilityProviderStrategy>(new InjectionConstructor(
new ResolvedArrayParameter <ISiteMapNodeVisibilityProvider>(this.Container.ResolveAll <ISiteMapNodeVisibilityProvider>().ToArray()),
new InjectionParameter <string>(string.Empty)
));
// Dynamic Node Providers
this.Container.RegisterType <IDynamicNodeProviderStrategy, DynamicNodeProviderStrategy>(new InjectionConstructor(
new ResolvedArrayParameter <IDynamicNodeProvider>(this.Container.ResolveAll <IDynamicNodeProvider>().ToArray())
));
// Pass in the global controllerBuilder reference
this.Container.RegisterInstance <ControllerBuilder>(ControllerBuilder.Current);
this.Container.RegisterType <IControllerTypeResolverFactory, ControllerTypeResolverFactory>(new InjectionConstructor(
new List <string>(),
new ResolvedParameter <IControllerBuilder>(),
new ResolvedParameter <IBuildManager>()));
// Configure Security
// IMPORTANT: Must give arrays of object a name in Unity in order for it to resolve them.
this.Container.RegisterType <IAclModule, AuthorizeAttributeAclModule>("authorizeAttribute");
this.Container.RegisterType <IAclModule, XmlRolesAclModule>("xmlRoles");
this.Container.RegisterType <IAclModule, CompositeAclModule>(new InjectionConstructor(new ResolvedArrayParameter <IAclModule>(
new ResolvedParameter <IAclModule>("authorizeAttribute"),
new ResolvedParameter <IAclModule>("xmlRoles"))));
this.Container.RegisterInstance <System.Runtime.Caching.ObjectCache>(System.Runtime.Caching.MemoryCache.Default);
this.Container.RegisterType(typeof(ICacheProvider <>), typeof(RuntimeCacheProvider <>));
this.Container.RegisterType <ICacheDependency, RuntimeFileCacheDependency>(
"cacheDependency", new InjectionConstructor(absoluteFileName));
this.Container.RegisterType <ICacheDetails, CacheDetails>("cacheDetails",
new InjectionConstructor(absoluteCacheExpiration, TimeSpan.MinValue, new ResolvedParameter <ICacheDependency>("cacheDependency")));
// Configure the visitors
this.Container.RegisterType <ISiteMapNodeVisitor, UrlResolvingSiteMapNodeVisitor>();
// Prepare for the sitemap node providers
this.Container.RegisterType <IXmlSource, FileXmlSource>("file1XmlSource", new InjectionConstructor(absoluteFileName));
this.Container.RegisterType <IReservedAttributeNameProvider, ReservedAttributeNameProvider>(new InjectionConstructor(new List <string>()));
// IMPORTANT: Must give arrays of object a name in Unity in order for it to resolve them.
// Register the sitemap node providers
this.Container.RegisterInstance <ISiteMapNodeProvider>("xmlSiteMapNodeProvider1",
this.Container.Resolve <XmlSiteMapNodeProviderFactory>().Create(this.Container.Resolve <IXmlSource>("file1XmlSource")), new ContainerControlledLifetimeManager());
this.Container.RegisterInstance <ISiteMapNodeProvider>("reflectionSiteMapNodeProvider1",
this.Container.Resolve <ReflectionSiteMapNodeProviderFactory>().Create(includeAssembliesForScan), new ContainerControlledLifetimeManager());
this.Container.RegisterType <ISiteMapNodeProvider, CompositeSiteMapNodeProvider>(new InjectionConstructor(new ResolvedArrayParameter <ISiteMapNodeProvider>(
new ResolvedParameter <ISiteMapNodeProvider>("xmlSiteMapNodeProvider1"),
new ResolvedParameter <ISiteMapNodeProvider>("reflectionSiteMapNodeProvider1"))));
// Configure the builders
this.Container.RegisterType <ISiteMapBuilder, SiteMapBuilder>();
// Configure the builder sets
this.Container.RegisterType <ISiteMapBuilderSet, SiteMapBuilderSet>("builderSet1",
new InjectionConstructor(
"default",
securityTrimmingEnabled,
enableLocalization,
visibilityAffectsDescendants,
useTitleIfDescriptionNotProvided,
new ResolvedParameter <ISiteMapBuilder>(),
new ResolvedParameter <ICacheDetails>("cacheDetails")));
this.Container.RegisterType <ISiteMapBuilderSetStrategy, SiteMapBuilderSetStrategy>(new InjectionConstructor(
new ResolvedArrayParameter <ISiteMapBuilderSet>(new ResolvedParameter <ISiteMapBuilderSet>("builderSet1"))));
}
public static UploadFileResult UploadFile(HttpPostedFileBase file, string uploadFolderPath, ILocalizationService localizationService, bool onlyImages = false)
{
var upResult = new UploadFileResult {
UploadSuccessful = true
};
const string imageExtensions = "jpg,jpeg,png,gif";
var fileName = Path.GetFileName(file.FileName);
if (fileName != null)
{
// Lower case
fileName = fileName.ToLower();
// Get the file extension
var fileExtension = Path.GetExtension(fileName.ToLower());
//Before we do anything, check file size
if (file.ContentLength > Convert.ToInt32(SiteConstants.FileUploadMaximumFileSizeInBytes))
{
//File is too big
upResult.UploadSuccessful = false;
upResult.ErrorMessage = localizationService.GetResourceString("Post.UploadFileTooBig");
return(upResult);
}
// now check allowed extensions
var allowedFileExtensions = SiteConstants.FileUploadAllowedExtensions;
if (onlyImages)
{
allowedFileExtensions = imageExtensions;
}
if (!string.IsNullOrEmpty(allowedFileExtensions))
{
// Turn into a list and strip unwanted commas as we don't trust users!
var allowedFileExtensionsList = allowedFileExtensions.ToLower().Trim()
.TrimStart(',').TrimEnd(',').Split(',').ToList();
// If can't work out extension then just error
if (string.IsNullOrEmpty(fileExtension))
{
upResult.UploadSuccessful = false;
upResult.ErrorMessage = localizationService.GetResourceString("Errors.GenericMessage");
return(upResult);
}
// Remove the dot then check against the extensions in the web.config settings
fileExtension = fileExtension.TrimStart('.');
if (!allowedFileExtensionsList.Contains(fileExtension))
{
upResult.UploadSuccessful = false;
upResult.ErrorMessage = localizationService.GetResourceString("Post.UploadBannedFileExtension");
return(upResult);
}
}
// Store these here as we may change the values within the image manipulation
var newFileName = string.Empty;
var path = string.Empty;
if (imageExtensions.Split(',').ToList().Contains(fileExtension))
{
// Rotate image if wrong want around
using (var sourceimage = Image.FromStream(file.InputStream))
{
if (sourceimage.PropertyIdList.Contains(0x0112))
{
int rotationValue = sourceimage.GetPropertyItem(0x0112).Value[0];
switch (rotationValue)
{
case 1: // landscape, do nothing
break;
case 8: // rotated 90 right
// de-rotate:
sourceimage.RotateFlip(RotateFlipType.Rotate270FlipNone);
break;
case 3: // bottoms up
sourceimage.RotateFlip(RotateFlipType.Rotate180FlipNone);
break;
case 6: // rotated 90 left
sourceimage.RotateFlip(RotateFlipType.Rotate90FlipNone);
break;
}
}
using (var stream = new MemoryStream())
{
// Save the image as a Jpeg only
sourceimage.Save(stream, ImageFormat.Jpeg);
stream.Position = 0;
// Change the extension to jpg as that's what we are saving it as
fileName = fileName.Replace(fileExtension, "");
fileName = string.Concat(fileName, "jpg");
file = new MemoryFile(stream, "image/jpeg", fileName);
// Sort the file name
newFileName = CreateNewFileName(fileName);
path = Path.Combine(uploadFolderPath, newFileName);
// Save the file to disk
file.SaveAs(path);
}
}
}
else
{
// Sort the file name
newFileName = CreateNewFileName(fileName);
path = Path.Combine(uploadFolderPath, newFileName);
// Save the file to disk
file.SaveAs(path);
}
var hostingRoot = HostingEnvironment.MapPath("~/") ?? "";
var fileUrl = path.Substring(hostingRoot.Length).Replace('\\', '/').Insert(0, "/");
upResult.UploadedFileName = newFileName;
upResult.UploadedFileUrl = fileUrl;
}
return(upResult);
}
public SupplierIndexModel(ApplicationDbContext context, HostingEnvironment hostingEnvironment)
{
_context = context;
_hostingEnvironment = hostingEnvironment;
}
protected override void Load(ContainerBuilder builder)
{
var diagnosticsService = new DiagnosticsService();
builder.RegisterInstance(diagnosticsService)
.AsSelf()
.As <IDiagnosticsService>()
.SingleInstance();
var configuration = new ConfigurationService(new SecretReaderFactory(diagnosticsService));
builder.RegisterInstance(configuration)
.AsSelf()
.As <PoliteCaptcha.IConfigurationSource>();
builder.RegisterInstance(configuration)
.AsSelf()
.As <IGalleryConfigurationService>();
builder.Register(c => configuration.Current)
.AsSelf()
.As <IAppConfiguration>();
// Force the read of this configuration, so it will be initialized on startup
builder.Register(c => configuration.Features)
.AsSelf()
.As <FeatureConfiguration>();
builder.RegisterType <TelemetryService>().As <ITelemetryService>().SingleInstance();
builder.RegisterType <CredentialBuilder>().As <ICredentialBuilder>().SingleInstance();
builder.RegisterType <CredentialValidator>().As <ICredentialValidator>().SingleInstance();
builder.RegisterInstance(LuceneCommon.GetDirectory(configuration.Current.LuceneIndexLocation))
.As <Lucene.Net.Store.Directory>()
.SingleInstance();
ConfigureSearch(builder, configuration);
if (!string.IsNullOrEmpty(configuration.Current.AzureStorageConnectionString))
{
builder.RegisterInstance(new TableErrorLog(configuration.Current.AzureStorageConnectionString))
.As <ErrorLog>()
.SingleInstance();
}
else
{
builder.RegisterInstance(new SqlErrorLog(configuration.Current.SqlConnectionString))
.As <ErrorLog>()
.SingleInstance();
}
builder.RegisterType <DateTimeProvider>().AsSelf().As <IDateTimeProvider>().SingleInstance();
builder.RegisterType <HttpContextCacheService>()
.AsSelf()
.As <ICacheService>()
.InstancePerLifetimeScope();
builder.RegisterType <ContentService>()
.AsSelf()
.As <IContentService>()
.SingleInstance();
builder.Register(c => new EntitiesContext(configuration.Current.SqlConnectionString, readOnly: configuration.Current.ReadOnlyMode))
.AsSelf()
.As <IEntitiesContext>()
.As <DbContext>()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <User> >()
.AsSelf()
.As <IEntityRepository <User> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <CuratedFeed> >()
.AsSelf()
.As <IEntityRepository <CuratedFeed> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <CuratedPackage> >()
.AsSelf()
.As <IEntityRepository <CuratedPackage> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageRegistration> >()
.AsSelf()
.As <IEntityRepository <PackageRegistration> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <Package> >()
.AsSelf()
.As <IEntityRepository <Package> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageDependency> >()
.AsSelf()
.As <IEntityRepository <PackageDependency> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageDelete> >()
.AsSelf()
.As <IEntityRepository <PackageDelete> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <Credential> >()
.AsSelf()
.As <IEntityRepository <Credential> >()
.InstancePerLifetimeScope();
builder.RegisterType <EntityRepository <PackageOwnerRequest> >()
.AsSelf()
.As <IEntityRepository <PackageOwnerRequest> >()
.InstancePerLifetimeScope();
builder.RegisterType <CuratedFeedService>()
.AsSelf()
.As <ICuratedFeedService>()
.InstancePerLifetimeScope();
builder.Register(c => new SupportRequestDbContext(configuration.Current.SqlConnectionStringSupportRequest))
.AsSelf()
.As <ISupportRequestDbContext>()
.InstancePerLifetimeScope();
builder.RegisterType <SupportRequestService>()
.AsSelf()
.As <ISupportRequestService>()
.InstancePerLifetimeScope();
builder.RegisterType <UserService>()
.AsSelf()
.As <IUserService>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageNamingConflictValidator>()
.AsSelf()
.As <IPackageNamingConflictValidator>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageService>()
.AsSelf()
.As <IPackageService>()
.InstancePerLifetimeScope();
builder.RegisterType <PackageDeleteService>()
.AsSelf()
.As <IPackageDeleteService>()
.InstancePerLifetimeScope();
builder.RegisterType <EditPackageService>()
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterType <FormsAuthenticationService>()
.As <IFormsAuthenticationService>()
.InstancePerLifetimeScope();
builder.RegisterType <CookieTempDataProvider>()
.As <ITempDataProvider>()
.InstancePerLifetimeScope();
builder.RegisterType <NuGetExeDownloaderService>()
.AsSelf()
.As <INuGetExeDownloaderService>()
.InstancePerLifetimeScope();
builder.RegisterType <StatusService>()
.AsSelf()
.As <IStatusService>()
.InstancePerLifetimeScope();
builder.RegisterType <SecurityPolicyService>()
.AsSelf()
.As <ISecurityPolicyService>()
.InstancePerLifetimeScope();
builder.RegisterType <SecurePushSubscription>()
.SingleInstance();
builder.RegisterType <RequireSecurePushForCoOwnersPolicy>()
.SingleInstance();
var mailSenderThunk = new Lazy <IMailSender>(
() =>
{
var settings = configuration;
if (settings.Current.SmtpUri != null && settings.Current.SmtpUri.IsAbsoluteUri)
{
var smtpUri = new SmtpUri(settings.Current.SmtpUri);
var mailSenderConfiguration = new MailSenderConfiguration
{
DeliveryMethod = SmtpDeliveryMethod.Network,
Host = smtpUri.Host,
Port = smtpUri.Port,
EnableSsl = smtpUri.Secure
};
if (!string.IsNullOrWhiteSpace(smtpUri.UserName))
{
mailSenderConfiguration.UseDefaultCredentials = false;
mailSenderConfiguration.Credentials = new NetworkCredential(
smtpUri.UserName,
smtpUri.Password);
}
return(new MailSender(mailSenderConfiguration));
}
else
{
var mailSenderConfiguration = new MailSenderConfiguration
{
DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
PickupDirectoryLocation = HostingEnvironment.MapPath("~/App_Data/Mail")
};
return(new MailSender(mailSenderConfiguration));
}
});
builder.Register(c => mailSenderThunk.Value)
.AsSelf()
.As <IMailSender>()
.InstancePerLifetimeScope();
builder.RegisterType <MessageService>()
.AsSelf()
.As <IMessageService>()
.InstancePerLifetimeScope();
builder.Register(c => HttpContext.Current.User)
.AsSelf()
.As <IPrincipal>()
.InstancePerLifetimeScope();
IAuditingService defaultAuditingService = null;
switch (configuration.Current.StorageType)
{
case StorageType.FileSystem:
case StorageType.NotSpecified:
ConfigureForLocalFileSystem(builder, configuration);
defaultAuditingService = GetAuditingServiceForLocalFileSystem(configuration);
break;
case StorageType.AzureStorage:
ConfigureForAzureStorage(builder, configuration);
defaultAuditingService = GetAuditingServiceForAzureStorage(configuration);
break;
}
RegisterAuditingServices(builder, defaultAuditingService);
builder.RegisterType <FileSystemService>()
.AsSelf()
.As <IFileSystemService>()
.SingleInstance();
builder.RegisterType <PackageFileService>()
.AsSelf()
.As <IPackageFileService>()
.InstancePerLifetimeScope();
builder.RegisterType <UploadFileService>()
.AsSelf()
.As <IUploadFileService>()
.InstancePerLifetimeScope();
// todo: bind all package curators by convention
builder.RegisterType <WebMatrixPackageCurator>()
.AsSelf()
.As <IAutomaticPackageCurator>()
.InstancePerLifetimeScope();
builder.RegisterType <Windows8PackageCurator>()
.AsSelf()
.As <IAutomaticPackageCurator>()
.InstancePerLifetimeScope();
// todo: bind all commands by convention
builder.RegisterType <AutomaticallyCuratePackageCommand>()
.AsSelf()
.As <IAutomaticallyCuratePackageCommand>()
.InstancePerLifetimeScope();
if (configuration.Current.Environment == Constants.DevelopmentEnvironment)
{
builder.RegisterType <AllowLocalHttpRedirectPolicy>()
.As <ISourceDestinationRedirectPolicy>()
.InstancePerLifetimeScope();
}
else
{
builder.RegisterType <NoLessSecureDestinationRedirectPolicy>()
.As <ISourceDestinationRedirectPolicy>()
.InstancePerLifetimeScope();
}
ConfigureAutocomplete(builder, configuration);
}
/// <summary>
/// Automatically creates a database for the template if it doesn't already exists.
/// You might delete this method to disable auto create functionality.
/// </summary>
private static void EnsureDatabase(string databaseKey)
{
var cs = SqlConnections.GetConnectionString(databaseKey);
if (cs.Dialect.GetType() == typeof(OracleDialect))
{
return;
}
var cb = cs.ProviderFactory.CreateConnectionStringBuilder();
cb.ConnectionString = cs.ConnectionString;
string catalogKey = "?";
foreach (var ck in new[] { "Initial Catalog", "Database", "AttachDBFilename" })
{
if (cb.ContainsKey(ck))
{
catalogKey = ck;
break;
}
}
var catalog = cb[catalogKey] as string;
cb[catalogKey] = null;
using (var serverConnection = SqlConnections.New(cb.ConnectionString, cs.ProviderName))
{
try
{
serverConnection.Open();
}
catch (SqlException ex)
{
if (ex.ErrorCode != -2146232060)
{
throw;
}
const string oldVer = @"\v11.0";
if (cb.ConnectionString.IndexOf(oldVer) >= 0)
{
throw new Exception(
"You don't seem to have SQL Express LocalDB 2012 installed.\r\n\r\n" +
"If you have Visual Studio 2015 (with SQL LocalDB 2014) " +
"try changing '" + databaseKey + "' connection string in WEB.CONFIG to:\r\n\r\n" +
cs.ConnectionString.Replace(oldVer, @"\MSSqlLocalDB") + "\r\n\r\nor:\r\n\r\n" +
cs.ConnectionString.Replace(oldVer, @"\v12.0") + "';\r\n\r\n" +
"You can also try another SQL server type like .\\SQLExpress.");
}
throw;
}
string databasesQuery = "SELECT * FROM sys.databases WHERE NAME = @name";
string createDatabaseQuery = @"CREATE DATABASE [{0}]";
if (String.Equals(cs.ProviderName, "npgsql", StringComparison.OrdinalIgnoreCase))
{
databasesQuery = "select * from postgres.pg_catalog.pg_database where datname = @name";
createDatabaseQuery = "CREATE DATABASE \"{0}\"";
}
if (String.Equals(cs.ProviderName, "MySql.Data.MySqlClient", StringComparison.OrdinalIgnoreCase))
{
databasesQuery = "SELECT * FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = @name";
createDatabaseQuery = "CREATE DATABASE `{0}`";
}
if (serverConnection.Query(databasesQuery, new { name = catalog }).Any())
{
return;
}
var isLocalServer = serverConnection.ConnectionString.IndexOf(@"(localdb)\", StringComparison.OrdinalIgnoreCase) >= 0 ||
serverConnection.ConnectionString.IndexOf(@".\") >= 0;
string command;
if (isLocalServer)
{
var filename = Path.Combine(HostingEnvironment.MapPath("~/App_Data"), catalog);
command = String.Format(@"CREATE DATABASE [{0}] ON PRIMARY (Name = N'{0}', FILENAME = '{1}.mdf') LOG ON (NAME = N'{0}_log', FILENAME = '{1}.ldf')",
catalog, filename);
if (File.Exists(filename + ".mdf"))
{
command += " FOR ATTACH";
}
}
else
{
command = String.Format(createDatabaseQuery, catalog);
}
serverConnection.Execute(command);
SqlConnection.ClearAllPools();
}
}
public void StartupLoaderCanLoadByType()
{
var serviceCollection = new ServiceCollection();
var services = serviceCollection.BuildServiceProvider();
var diagnosticMessages = new List<string>();
var hostingEnv = new HostingEnvironment();
var loader = new StartupLoader(services, hostingEnv);
var startup = loader.LoadMethods(typeof(TestStartup), diagnosticMessages);
var app = new ApplicationBuilder(services);
app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection);
startup.ConfigureDelegate(app);
var foo = app.ApplicationServices.GetRequiredService<SimpleService>();
Assert.Equal("Configure", foo.Message);
}
public bool Post([FromBody] Komentar k)
{
Korisnik user = (Korisnik)HttpContext.Current.Session["user"];
if (user == null)
{
user = new Korisnik();
HttpContext.Current.Session["user"] = user;
}
Korisnici users = HttpContext.Current.Application["korisnici"] as Korisnici;
Voznje voznje = HttpContext.Current.Application["voznje"] as Voznje;
foreach (Korisnik korisnik in users.korisnici)
{
if (korisnik.KorisnickoIme == user.KorisnickoIme)
{
foreach (Voznja ride in korisnik.voznjeKorisnika)
{
if (ride.IdVoznje == k.IdVoznje)
{
ride.Komentar.IdVoznje = k.IdVoznje;
ride.Komentar.DatumObjave = DateTime.UtcNow;
ride.Komentar.KorisnickoIme = user.KorisnickoIme;
ride.Komentar.OcenaVoznje = k.OcenaVoznje;
ride.Komentar.Opis = k.Opis;
//string path = @"C:\Users\Coa\Desktop\NovaVerzija\WebAPI\WebAPI\App_Data\voznje.txt";
string path = "~/App_Data/voznje.txt";
path = HostingEnvironment.MapPath(path);
string line = String.Empty;
line = ride.IdVoznje.ToString() + '|' + ride.VremePorudzbine.ToString() + '|' + ride.LokacijaDolaskaTaksija.X + '|' + ride.LokacijaDolaskaTaksija.Y + '|' +
ride.LokacijaDolaskaTaksija.Adresa.UlicaBroj + '|' + ride.LokacijaDolaskaTaksija.Adresa.NaseljenoMesto + '|' + ride.LokacijaDolaskaTaksija.Adresa.PozivniBroj + '|' + ride.Automobil + '|' +
ride.Musterija + '|' + ride.Odrediste.X + '|' + ride.Odrediste.Y + '|' + ride.Odrediste.Adresa.UlicaBroj + '|' + ride.Odrediste.Adresa.NaseljenoMesto + '|' + ride.Odrediste.Adresa.PozivniBroj + '|' +
ride.Dispecer + '|' + ride.Vozac + '|' + ride.Iznos + '|' + ride.Komentar.Opis + '|' + ride.Komentar.DatumObjave + '|' + ride.Komentar.KorisnickoIme + '|' +
ride.Komentar.OcenaVoznje + '|' + ride.Status + '|' + Environment.NewLine;
string[] arrLine = File.ReadAllLines(path);
arrLine[ride.IdVoznje] = line;
File.WriteAllLines(path, arrLine);
File.WriteAllLines(path, File.ReadAllLines(path).Where(l => !string.IsNullOrWhiteSpace(l)));
foreach (Korisnik kor in users.korisnici)
{
if (kor.KorisnickoIme == ride.Musterija)
{
foreach (Voznja voznja in kor.voznjeKorisnika)
{
if (voznja.IdVoznje == ride.IdVoznje)
{
voznja.Komentar = ride.Komentar;
}
}
}
}
Voznje voznje2 = new Voznje("~/App_Data/voznje.txt");
HttpContext.Current.Application["voznje"] = voznje2;
HttpContext.Current.Application["korisnici"] = users;
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Gets the log files from the default log file directory
/// </summary>
/// <returns>A collection of log file items</returns>
public IEnumerable <LogFileItem> GetLogFiles()
{
string fullPath = HostingEnvironment.MapPath(BaseLogPath);
return(GetLogFilesFromPath(fullPath));
}
public void Stop(bool immediate)
{
this.timer.Dispose();
HostingEnvironment.UnregisterObject(this);
}
public override Stream Open()
{
return(File.Open(HostingEnvironment.MapPath(VirtualPath), FileMode.Open, FileAccess.Read));
}
public Voznje(string path)
{
Korisnici korisnici = HttpContext.Current.Application["korisnici"] as Korisnici;
Vozaci vozaci = HttpContext.Current.Application["vozaci"] as Vozaci;
Dispeceri dispeceri = HttpContext.Current.Application["dispeceri"] as Dispeceri;
foreach (Korisnik k in korisnici.korisnici)
{
k.voznjeKorisnika = new List <Voznja>();
}
foreach (Dispecer k in dispeceri.dispecers)
{
k.voznjeKorisnika = new List <Voznja>();
}
foreach (Vozac k in vozaci.vozaci)
{
k.voznjeKorisnika = new List <Voznja>();
}
path = HostingEnvironment.MapPath(path);
voznje = new List <Voznja>();
FileStream stream = new FileStream(path, FileMode.Open);
StreamReader sr = new StreamReader(stream);
string line = "";
while ((line = sr.ReadLine()) != null)
{
if (line == null || line == "")
{
break;
}
string[] tokens = line.Split('|');
Voznja d = new Voznja(Int32.Parse(tokens[0]), tokens[1], tokens[2], tokens[3], tokens[4], tokens[5], tokens[6], tokens[7], tokens[8], tokens[9], tokens[10], tokens[11], tokens[12], tokens[13], tokens[14], tokens[15], tokens[16], tokens[17], tokens[18], tokens[19], tokens[20], tokens[21]);
voznje.Add(d);
//tokens[8]
foreach (Korisnik k in korisnici.korisnici)
{
if (k.KorisnickoIme == tokens[8])
{
k.voznjeKorisnika.Add(d);
}
}
//tokens[15]
foreach (Vozac vozac in vozaci.vozaci)
{
if (tokens[15] == vozac.KorisnickoIme)
{
vozac.voznjeKorisnika.Add(d);
}
}
//tokens[14]
foreach (Dispecer dispecer in dispeceri.dispecers)
{
if (tokens[14] == dispecer.KorisnickoIme)
{
dispecer.voznjeKorisnika.Add(d);
}
}
}
sr.Close();
stream.Close();
}
protected virtual InstallationResult InstallCore(ILifetimeScope scope, InstallModel model)
{
UpdateResult(x =>
{
x.ProgressMessage = _locService.GetResource("Progress.CheckingRequirements");
x.Completed = false;
Logger.Info(x.ProgressMessage);
});
if (DataSettings.DatabaseIsInstalled())
{
return(UpdateResult(x =>
{
x.Success = true;
x.RedirectUrl = Url.Action("Index", "Home");
Logger.Info("Application already installed");
}));
}
//set page timeout to 5 minutes
this.Server.ScriptTimeout = 300;
if (model.DatabaseConnectionString != null)
{
model.DatabaseConnectionString = model.DatabaseConnectionString.Trim();
}
//SQL Server
if (model.DataProvider.Equals("sqlserver", StringComparison.InvariantCultureIgnoreCase))
{
if (model.SqlConnectionInfo.Equals("sqlconnectioninfo_raw", StringComparison.InvariantCultureIgnoreCase))
{
//raw connection string
if (string.IsNullOrEmpty(model.DatabaseConnectionString))
{
UpdateResult(x =>
{
x.Errors.Add(_locService.GetResource("ConnectionStringRequired"));
Logger.Error(x.Errors.Last());
});
}
try
{
//try to create connection string
new SqlConnectionStringBuilder(model.DatabaseConnectionString);
}
catch (Exception ex)
{
UpdateResult(x =>
{
x.Errors.Add(_locService.GetResource("ConnectionStringWrongFormat"));
Logger.Error(ex, x.Errors.Last());
});
}
}
else
{
//values
if (string.IsNullOrEmpty(model.SqlServerName))
{
UpdateResult(x =>
{
x.Errors.Add(_locService.GetResource("SqlServerNameRequired"));
Logger.Error(x.Errors.Last());
});
}
if (string.IsNullOrEmpty(model.SqlDatabaseName))
{
UpdateResult(x =>
{
x.Errors.Add(_locService.GetResource("DatabaseNameRequired"));
Logger.Error(x.Errors.Last());
});
}
//authentication type
if (model.SqlAuthenticationType.Equals("sqlauthentication", StringComparison.InvariantCultureIgnoreCase))
{
//SQL authentication
if (string.IsNullOrEmpty(model.SqlServerUsername))
{
UpdateResult(x =>
{
x.Errors.Add(_locService.GetResource("SqlServerUsernameRequired"));
Logger.Error(x.Errors.Last());
});
}
if (string.IsNullOrEmpty(model.SqlServerPassword))
{
UpdateResult(x =>
{
x.Errors.Add(_locService.GetResource("SqlServerPasswordRequired"));
Logger.Error(x.Errors.Last());
});
}
}
}
}
//Consider granting access rights to the resource to the ASP.NET request identity.
//ASP.NET has a base process identity
//(typically {MACHINE}\ASPNET on IIS 5 or Network Service on IIS 6 and IIS 7,
//and the configured application pool identity on IIS 7.5) that is used if the application is not impersonating.
//If the application is impersonating via <identity impersonate="true"/>,
//the identity will be the anonymous user (typically IUSR_MACHINENAME) or the authenticated request user.
var webHelper = scope.Resolve <IWebHelper>();
//validate permissions
var dirsToCheck = FilePermissionHelper.GetDirectoriesWrite(webHelper);
foreach (string dir in dirsToCheck)
{
if (!FilePermissionHelper.CheckPermissions(dir, false, true, true, false))
{
UpdateResult(x =>
{
x.Errors.Add(string.Format(_locService.GetResource("ConfigureDirectoryPermissions"), WindowsIdentity.GetCurrent().Name, dir));
Logger.Error(x.Errors.Last());
});
}
}
var filesToCheck = FilePermissionHelper.GetFilesWrite(webHelper);
foreach (string file in filesToCheck)
{
if (!FilePermissionHelper.CheckPermissions(file, false, true, true, true))
{
UpdateResult(x =>
{
x.Errors.Add(string.Format(_locService.GetResource("ConfigureFilePermissions"), WindowsIdentity.GetCurrent().Name, file));
Logger.Error(x.Errors.Last());
});
}
}
if (GetInstallResult().HasErrors)
{
return(UpdateResult(x =>
{
x.Completed = true;
x.Success = false;
x.RedirectUrl = null;
Logger.Error("Aborting installation.");
}));
}
else
{
SmartObjectContext dbContext = null;
var shouldDeleteDbOnFailure = false;
try
{
string connectionString = null;
if (model.DataProvider.Equals("sqlserver", StringComparison.InvariantCultureIgnoreCase))
{
//SQL Server
if (model.SqlConnectionInfo.Equals("sqlconnectioninfo_raw", StringComparison.InvariantCultureIgnoreCase))
{
//raw connection string
//we know that MARS option is required when using Entity Framework
//let's ensure that it's specified
var sqlCsb = new SqlConnectionStringBuilder(model.DatabaseConnectionString);
sqlCsb.MultipleActiveResultSets = true;
connectionString = sqlCsb.ToString();
}
else
{
//values
connectionString = CreateConnectionString(
model.SqlAuthenticationType == "windowsauthentication",
model.SqlServerName, model.SqlDatabaseName,
model.SqlServerUsername, model.SqlServerPassword);
}
if (model.SqlServerCreateDatabase)
{
if (!SqlServerDatabaseExists(connectionString))
{
//create database
var collation = model.UseCustomCollation ? model.Collation : "";
var errorCreatingDatabase = CreateDatabase(connectionString, collation);
if (errorCreatingDatabase.HasValue())
{
return(UpdateResult(x =>
{
x.Errors.Add(errorCreatingDatabase);
x.Completed = true;
x.Success = false;
x.RedirectUrl = null;
Logger.Error(errorCreatingDatabase);
}));
}
else
{
// Database cannot be created sometimes. Weird! Seems to be Entity Framework issue
// that's just wait 3 seconds
Thread.Sleep(3000);
shouldDeleteDbOnFailure = true;
}
}
}
else
{
//check whether database exists
if (!SqlServerDatabaseExists(connectionString))
{
return(UpdateResult(x =>
{
x.Errors.Add(_locService.GetResource("DatabaseNotExists"));
x.Completed = true;
x.Success = false;
x.RedirectUrl = null;
Logger.Error(x.Errors.Last());
}));
}
}
}
else
{
// SQL CE
string databaseFileName = "SmartStore.Db.sdf";
string databasePath = @"|DataDirectory|\Tenants\{0}\{1}".FormatInvariant(DataSettings.Current.TenantName, databaseFileName);
connectionString = "Data Source=" + databasePath + "; Persist Security Info=False";
// drop database if exists
string databaseFullPath = HostingEnvironment.MapPath(DataSettings.Current.TenantPath.EnsureEndsWith("/")) + databaseFileName;
if (System.IO.File.Exists(databaseFullPath))
{
System.IO.File.Delete(databaseFullPath);
}
shouldDeleteDbOnFailure = true;
}
// save settings
var dataProvider = model.DataProvider;
var settings = DataSettings.Current;
settings.AppVersion = SmartStoreVersion.Version;
settings.DataProvider = dataProvider;
settings.DataConnectionString = connectionString;
settings.Save();
// init data provider
var dataProviderInstance = scope.Resolve <IEfDataProvider>();
// Although obsolete we have no other chance than using this here.
// Delegating this to DbConfiguration is not possible during installation.
#pragma warning disable 618
Database.DefaultConnectionFactory = dataProviderInstance.GetConnectionFactory();
#pragma warning restore 618
// resolve SeedData instance from primary language
var lazyLanguage = _locService.GetAppLanguage(model.PrimaryLanguage);
if (lazyLanguage == null)
{
return(UpdateResult(x =>
{
x.Errors.Add(_locService.GetResource("Install.LanguageNotRegistered").FormatInvariant(model.PrimaryLanguage));
x.Completed = true;
x.Success = false;
x.RedirectUrl = null;
Logger.Error(x.Errors.Last());
}));
}
// create the DataContext
dbContext = new SmartObjectContext();
// AuditableHook must run during install
dbContext.DbHookHandler = new DefaultDbHookHandler(new[]
{
new Lazy <IDbHook, HookMetadata>(() => new AuditableHook(), HookMetadata.Create <AuditableHook>(typeof(IAuditable), true), false)
});
// IMPORTANT: Migration would run way too early otherwise
Database.SetInitializer <SmartObjectContext>(null);
// create Language domain object from lazyLanguage
var languages = dbContext.Set <Language>();
var primaryLanguage = languages.Create(); // create a proxied type, resources cannot be saved otherwise
primaryLanguage.Name = lazyLanguage.Metadata.Name;
primaryLanguage.LanguageCulture = lazyLanguage.Metadata.Culture;
primaryLanguage.UniqueSeoCode = lazyLanguage.Metadata.UniqueSeoCode;
primaryLanguage.FlagImageFileName = lazyLanguage.Metadata.FlagImageFileName;
// Build the seed configuration model
var seedConfiguration = new SeedDataConfiguration
{
DefaultUserName = model.AdminEmail,
DefaultUserPassword = model.AdminPassword,
SeedSampleData = model.InstallSampleData,
Data = lazyLanguage.Value,
Language = primaryLanguage,
StoreMediaInDB = model.MediaStorage == "db",
ProgressMessageCallback = msg => UpdateResult(x => x.ProgressMessage = _locService.GetResource(msg))
};
var seeder = new InstallDataSeeder(seedConfiguration, Logger);
Database.SetInitializer(new InstallDatabaseInitializer()
{
DataSeeders = new[] { seeder }
});
UpdateResult(x =>
{
x.ProgressMessage = _locService.GetResource("Progress.BuildingDatabase");
Logger.Info(x.ProgressMessage);
});
// ===>>> actually performs the installation by calling "InstallDataSeeder.Seed()" internally
dbContext.Database.Initialize(true);
// install plugins
PluginManager.MarkAllPluginsAsUninstalled();
var pluginFinder = scope.Resolve <IPluginFinder>();
var plugins = pluginFinder.GetPlugins <IPlugin>(false)
//.ToList()
.OrderBy(x => x.PluginDescriptor.Group)
.ThenBy(x => x.PluginDescriptor.DisplayOrder)
.ToList();
var ignoredPluginsSetting = CommonHelper.GetAppSetting <string>("sm:PluginsIgnoredDuringInstallation");
var pluginsIgnoredDuringInstallation = String.IsNullOrEmpty(ignoredPluginsSetting) ?
new List <string>() :
ignoredPluginsSetting
.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
if (pluginsIgnoredDuringInstallation.Count > 0)
{
plugins = plugins.Where(x => !pluginsIgnoredDuringInstallation.Contains(x.PluginDescriptor.SystemName, StringComparer.OrdinalIgnoreCase)).ToList();
}
var pluginsCount = plugins.Count;
var idx = 0;
using (var dbScope = new DbContextScope(autoDetectChanges: false, hooksEnabled: false)) {
foreach (var plugin in plugins)
{
try
{
idx++;
UpdateResult(x =>
{
x.ProgressMessage = _locService.GetResource("Progress.InstallingPlugins").FormatInvariant(idx, pluginsCount);
Logger.InfoFormat("Installing plugin '{0}'.", plugin.PluginDescriptor.FriendlyName ?? plugin.PluginDescriptor.SystemName);
});
plugin.Install();
dbScope.Commit();
}
catch (Exception ex)
{
Logger.Error(ex);
if (plugin.PluginDescriptor.Installed)
{
PluginManager.MarkPluginAsUninstalled(plugin.PluginDescriptor.SystemName);
}
}
}
}
UpdateResult(x =>
{
x.ProgressMessage = _locService.GetResource("Progress.Finalizing");
Logger.Info(x.ProgressMessage);
});
// Register default permissions
var permissionProviders = new List <Type>();
permissionProviders.Add(typeof(StandardPermissionProvider));
foreach (var providerType in permissionProviders)
{
dynamic provider = Activator.CreateInstance(providerType);
scope.Resolve <IPermissionService>().InstallPermissions(provider);
}
// do not ignore settings migrated by data seeder (e.g. default media storage provider)
scope.Resolve <ISettingService>().ClearCache();
// SUCCESS: Redirect to home page
return(UpdateResult(x =>
{
x.Completed = true;
x.Success = true;
x.RedirectUrl = Url.Action("Index", "Home");
Logger.Info("Installation completed successfully");
}));
}
catch (Exception exception)
{
Logger.Error(exception);
// Clear provider settings if something got wrong
DataSettings.Delete();
// Delete Db if it was auto generated
if (dbContext != null && shouldDeleteDbOnFailure)
{
try
{
Logger.Debug("Deleting database");
dbContext.Database.Delete();
}
catch { }
}
var msg = exception.Message;
var realException = exception;
while (realException.InnerException != null)
{
realException = realException.InnerException;
}
if (!Object.Equals(exception, realException))
{
msg += " (" + realException.Message + ")";
}
return(UpdateResult(x =>
{
x.Errors.Add(string.Format(_locService.GetResource("SetupFailed"), msg));
x.Success = false;
x.Completed = true;
x.RedirectUrl = null;
}));
}
finally
{
if (dbContext != null)
{
dbContext.Dispose();
}
}
}
}
private void ConfigureAuthServices(IServiceCollection services)
{
services.AddIdentity <ApplicationUser, IdentityRole <int> >(
options => { options.Lockout.AllowedForNewUsers = false; })
.AddEntityFrameworkStores <BuildAssetRegistryContext>();
services.AddContextAwareAuthenticationScheme(o =>
{
o.SelectScheme = p => p.StartsWithSegments("/api") ? PersonalAccessTokenDefaults.AuthenticationScheme : IdentityConstants.ApplicationScheme;
});
services.AddAuthentication()
.AddGitHubOAuth(Configuration.GetSection("GitHubAuthentication"), GitHubScheme)
.AddPersonalAccessToken <ApplicationUser>(
options =>
{
options.Events = new PersonalAccessTokenEvents <ApplicationUser>
{
OnSetTokenHash = async context =>
{
var dbContext = context.HttpContext.RequestServices
.GetRequiredService <BuildAssetRegistryContext>();
int userId = context.User.Id;
var token = new ApplicationUserPersonalAccessToken
{
ApplicationUserId = userId,
Name = context.Name,
Hash = context.Hash,
Created = DateTimeOffset.UtcNow
};
await dbContext.Set <ApplicationUserPersonalAccessToken>().AddAsync(token);
await dbContext.SaveChangesAsync();
return(token.Id);
},
OnGetTokenHash = async context =>
{
var dbContext = context.HttpContext.RequestServices
.GetRequiredService <BuildAssetRegistryContext>();
ApplicationUserPersonalAccessToken token = await dbContext
.Set <ApplicationUserPersonalAccessToken>()
.Where(t => t.Id == context.TokenId)
.Include(t => t.ApplicationUser)
.FirstOrDefaultAsync();
if (token != null)
{
context.Success(token.Hash, token.ApplicationUser);
}
},
OnValidatePrincipal = async context =>
{
ApplicationUser user = context.User;
var dbContext = context.HttpContext.RequestServices
.GetRequiredService <BuildAssetRegistryContext>();
var userManager = context.HttpContext.RequestServices
.GetRequiredService <UserManager <ApplicationUser> >();
var signInManager = context.HttpContext.RequestServices
.GetRequiredService <SignInManager <ApplicationUser> >();
await UpdateUserIfNeededAsync(user, dbContext, userManager, signInManager);
ClaimsPrincipal principal = await signInManager.CreateUserPrincipalAsync(user);
context.ReplacePrincipal(principal);
}
};
});
services.ConfigureExternalCookie(
options =>
{
options.ExpireTimeSpan = TimeSpan.FromMinutes(30);
options.ReturnUrlParameter = "returnUrl";
options.LoginPath = "/Account/SignIn";
options.Events = new CookieAuthenticationEvents
{
OnRedirectToLogin = ctx =>
{
if (ctx.Request.Path.StartsWithSegments("/api"))
{
ctx.Response.StatusCode = 401;
return(Task.CompletedTask);
}
ctx.Response.Redirect(ctx.RedirectUri);
return(Task.CompletedTask);
},
OnRedirectToAccessDenied = ctx =>
{
ctx.Response.StatusCode = 403;
return(Task.CompletedTask);
},
};
});
services.ConfigureApplicationCookie(
options =>
{
options.ExpireTimeSpan = LoginCookieLifetime;
options.SlidingExpiration = true;
options.Events = new CookieAuthenticationEvents
{
OnSigningIn = async ctx =>
{
var dbContext = ctx.HttpContext.RequestServices
.GetRequiredService <BuildAssetRegistryContext>();
var signInManager = ctx.HttpContext.RequestServices
.GetRequiredService <SignInManager <ApplicationUser> >();
var userManager = ctx.HttpContext.RequestServices
.GetRequiredService <UserManager <ApplicationUser> >();
ExternalLoginInfo info = await signInManager.GetExternalLoginInfoAsync();
var user = await userManager.GetUserAsync(ctx.Principal);
await UpdateUserTokenAsync(dbContext, userManager, user, info);
IdentityOptions identityOptions = ctx.HttpContext.RequestServices
.GetRequiredService <IOptions <IdentityOptions> >()
.Value;
// replace the ClaimsPrincipal we are about to serialize to the cookie with a reference
Claim claim = ctx.Principal.Claims.Single(
c => c.Type == identityOptions.ClaimsIdentity.UserIdClaimType);
Claim[] claims = { claim };
var identity = new ClaimsIdentity(claims, IdentityConstants.ApplicationScheme);
ctx.Principal = new ClaimsPrincipal(identity);
},
OnValidatePrincipal = async ctx =>
{
var dbContext = ctx.HttpContext.RequestServices
.GetRequiredService <BuildAssetRegistryContext>();
var userManager = ctx.HttpContext.RequestServices
.GetRequiredService <UserManager <ApplicationUser> >();
var signInManager = ctx.HttpContext.RequestServices
.GetRequiredService <SignInManager <ApplicationUser> >();
// extract the userId from the ClaimsPrincipal and read the user from the Db
ApplicationUser user = await userManager.GetUserAsync(ctx.Principal);
if (user == null)
{
ctx.RejectPrincipal();
}
else
{
await UpdateUserIfNeededAsync(user, dbContext, userManager, signInManager);
ClaimsPrincipal principal = await signInManager.CreateUserPrincipalAsync(user);
ctx.ReplacePrincipal(principal);
}
}
};
});
services.AddAuthorization(
options =>
{
options.AddPolicy(
MsftAuthorizationPolicyName,
policy =>
{
policy.RequireAuthenticatedUser();
if (!HostingEnvironment.IsDevelopment())
{
policy.RequireRole("github:team:dotnet:dnceng", "github:team:dotnet:arcade-contrib");
}
});
});
services.Configure <MvcOptions>(
options =>
{
options.Conventions.Add(new DefaultAuthorizeActionModelConvention(MsftAuthorizationPolicyName));
});
}
protected override void Load(ContainerBuilder builder)
{
bool enableLocalization = true;
string absoluteFileName = HostingEnvironment.MapPath("~/Mvc.sitemap");
TimeSpan absoluteCacheExpiration = TimeSpan.FromMinutes(5);
bool visibilityAffectsDescendants = true;
bool useTitleIfDescriptionNotProvided = true;
bool securityTrimmingEnabled = false;
string[] includeAssembliesForScan = new string[] { "PhotoSharingApp" };
var currentAssembly = this.GetType().Assembly;
var siteMapProviderAssembly = typeof(SiteMaps).Assembly;
var allAssemblies = new Assembly[] { currentAssembly, siteMapProviderAssembly };
var excludeTypes = new Type[] {
// Use this array to add types you wish to explicitly exclude from convention-based
// auto-registration. By default all types that either match I[TypeName] = [TypeName] or
// I[TypeName] = [TypeName]Adapter will be automatically wired up as long as they don't
// have the [ExcludeFromAutoRegistrationAttribute].
//
// If you want to override a type that follows the convention, you should add the name
// of either the implementation name or the interface that it inherits to this list and
// add your manual registration code below. This will prevent duplicate registrations
// of the types from occurring.
// Example:
// typeof(SiteMap),
// typeof(SiteMapNodeVisibilityProviderStrategy)
};
var multipleImplementationTypes = new Type[] {
typeof(ISiteMapNodeUrlResolver),
typeof(ISiteMapNodeVisibilityProvider),
typeof(IDynamicNodeProvider)
};
// Matching type name (I[TypeName] = [TypeName]) or matching type name + suffix Adapter (I[TypeName] = [TypeName]Adapter)
// and not decorated with the [ExcludeFromAutoRegistrationAttribute].
CommonConventions.RegisterDefaultConventions(
(interfaceType, implementationType) => builder.RegisterType(implementationType).As(interfaceType).SingleInstance(),
new Assembly[] { siteMapProviderAssembly },
allAssemblies,
excludeTypes,
string.Empty);
// Multiple implementations of strategy based extension points (and not decorated with [ExcludeFromAutoRegistrationAttribute]).
CommonConventions.RegisterAllImplementationsOfInterface(
(interfaceType, implementationType) => builder.RegisterType(implementationType).As(interfaceType).SingleInstance(),
multipleImplementationTypes,
allAssemblies,
excludeTypes,
string.Empty);
// Registration of internal controllers
CommonConventions.RegisterAllImplementationsOfInterface(
(interfaceType, implementationType) => builder.RegisterType(implementationType).As(interfaceType).AsSelf().InstancePerDependency(),
new Type[] { typeof(IController) },
new Assembly[] { siteMapProviderAssembly },
new Type[0],
string.Empty);
// Visibility Providers
builder.RegisterType <SiteMapNodeVisibilityProviderStrategy>()
.As <ISiteMapNodeVisibilityProviderStrategy>()
.WithParameter("defaultProviderName", string.Empty);
// Pass in the global controllerBuilder reference
builder.RegisterInstance(ControllerBuilder.Current)
.As <ControllerBuilder>();
builder.RegisterType <ControllerTypeResolverFactory>()
.As <IControllerTypeResolverFactory>()
.WithParameter("areaNamespacesToIgnore", new string[0]);
// Configure Security
builder.RegisterType <AuthorizeAttributeAclModule>()
.Named <IAclModule>("authorizeAttributeAclModule");
builder.RegisterType <XmlRolesAclModule>()
.Named <IAclModule>("xmlRolesAclModule");
builder.RegisterType <CompositeAclModule>()
.As <IAclModule>()
.WithParameter(
(p, c) => p.Name == "aclModules",
(p, c) => new[]
{
c.ResolveNamed <IAclModule>("authorizeAttributeAclModule"),
c.ResolveNamed <IAclModule>("xmlRolesAclModule")
});
builder.RegisterInstance(System.Runtime.Caching.MemoryCache.Default)
.As <System.Runtime.Caching.ObjectCache>();
builder.RegisterGeneric(typeof(RuntimeCacheProvider <>))
.As(typeof(ICacheProvider <>));
builder.RegisterType <RuntimeFileCacheDependency>()
.Named <ICacheDependency>("cacheDependency1")
.WithParameter("fileName", absoluteFileName);
builder.RegisterType <CacheDetails>()
.Named <ICacheDetails>("cacheDetails1")
.WithParameter("absoluteCacheExpiration", absoluteCacheExpiration)
.WithParameter("slidingCacheExpiration", TimeSpan.MinValue)
.WithParameter(
(p, c) => p.Name == "cacheDependency",
(p, c) => c.ResolveNamed <ICacheDependency>("cacheDependency1"));
// Configure the visitors
builder.RegisterType <UrlResolvingSiteMapNodeVisitor>()
.As <ISiteMapNodeVisitor>();
// Prepare for our node providers
builder.RegisterType <FileXmlSource>()
.Named <IXmlSource>("xmlSource1")
.WithParameter("fileName", absoluteFileName);
builder.RegisterType <ReservedAttributeNameProvider>()
.As <IReservedAttributeNameProvider>()
.WithParameter("attributesToIgnore", new string[0]);
// Register the sitemap node providers
builder.RegisterType <XmlSiteMapNodeProvider>()
.Named <ISiteMapNodeProvider>("xmlSiteMapNodeProvider1")
.WithParameter("includeRootNode", true)
.WithParameter("useNestedDynamicNodeRecursion", false)
.WithParameter(
(p, c) => p.Name == "xmlSource",
(p, c) => c.ResolveNamed <IXmlSource>("xmlSource1"));
builder.RegisterType <ReflectionSiteMapNodeProvider>()
.Named <ISiteMapNodeProvider>("reflectionSiteMapNodeProvider1")
.WithParameter("includeAssemblies", includeAssembliesForScan)
.WithParameter("excludeAssemblies", new string[0]);
builder.RegisterType <CompositeSiteMapNodeProvider>()
.Named <ISiteMapNodeProvider>("siteMapNodeProvider1")
.WithParameter(
(p, c) => p.Name == "siteMapNodeProviders",
(p, c) => new[]
{
c.ResolveNamed <ISiteMapNodeProvider>("xmlSiteMapNodeProvider1"),
c.ResolveNamed <ISiteMapNodeProvider>("reflectionSiteMapNodeProvider1")
});
// Register the sitemap builders
builder.RegisterType <SiteMapBuilder>()
.Named <ISiteMapBuilder>("siteMapBuilder1")
.WithParameter(
(p, c) => p.Name == "siteMapNodeProvider",
(p, c) => c.ResolveNamed <ISiteMapNodeProvider>("siteMapNodeProvider1"));
// Configure the builder sets
builder.RegisterType <SiteMapBuilderSet>()
.Named <ISiteMapBuilderSet>("builderSet1")
.WithParameter("instanceName", "default")
.WithParameter("securityTrimmingEnabled", securityTrimmingEnabled)
.WithParameter("enableLocalization", enableLocalization)
.WithParameter("visibilityAffectsDescendants", visibilityAffectsDescendants)
.WithParameter("useTitleIfDescriptionNotProvided", useTitleIfDescriptionNotProvided)
.WithParameter(
(p, c) => p.Name == "siteMapBuilder",
(p, c) => c.ResolveNamed <ISiteMapBuilder>("siteMapBuilder1"))
.WithParameter(
(p, c) => p.Name == "cacheDetails",
(p, c) => c.ResolveNamed <ICacheDetails>("cacheDetails1"));
builder.RegisterType <SiteMapBuilderSetStrategy>()
.As <ISiteMapBuilderSetStrategy>()
.WithParameter(
(p, c) => p.Name == "siteMapBuilderSets",
(p, c) => c.ResolveNamed <IEnumerable <ISiteMapBuilderSet> >("builderSet1"));
}
public override void Load()
{
var configuration = new ConfigurationService();
Bind <ConfigurationService>()
.ToMethod(context => configuration);
Bind <IAppConfiguration>()
.ToMethod(context => configuration.Current);
Bind <PoliteCaptcha.IConfigurationSource>()
.ToMethod(context => configuration);
Bind <Lucene.Net.Store.Directory>()
.ToMethod(_ => LuceneCommon.GetDirectory(configuration.Current.LuceneIndexLocation))
.InSingletonScope();
Bind <ISearchService>()
.To <LuceneSearchService>()
.InRequestScope();
if (!String.IsNullOrEmpty(configuration.Current.AzureStorageConnectionString))
{
Bind <ErrorLog>()
.ToMethod(_ => new TableErrorLog(configuration.Current.AzureStorageConnectionString))
.InSingletonScope();
}
else
{
Bind <ErrorLog>()
.ToMethod(_ => new SqlErrorLog(configuration.Current.SqlConnectionString))
.InSingletonScope();
}
Bind <ICacheService>()
.To <HttpContextCacheService>()
.InRequestScope();
Bind <IContentService>()
.To <ContentService>()
.InSingletonScope();
Bind <IEntitiesContext>()
.ToMethod(context => new EntitiesContext(configuration.Current.SqlConnectionString, readOnly: configuration.Current.ReadOnlyMode))
.InRequestScope();
Bind <IEntityRepository <User> >()
.To <EntityRepository <User> >()
.InRequestScope();
Bind <IEntityRepository <CuratedFeed> >()
.To <EntityRepository <CuratedFeed> >()
.InRequestScope();
Bind <IEntityRepository <CuratedPackage> >()
.To <EntityRepository <CuratedPackage> >()
.InRequestScope();
Bind <IEntityRepository <PackageRegistration> >()
.To <EntityRepository <PackageRegistration> >()
.InRequestScope();
Bind <IEntityRepository <Package> >()
.To <EntityRepository <Package> >()
.InRequestScope();
Bind <IEntityRepository <PackageDependency> >()
.To <EntityRepository <PackageDependency> >()
.InRequestScope();
Bind <IEntityRepository <PackageStatistics> >()
.To <EntityRepository <PackageStatistics> >()
.InRequestScope();
Bind <IEntityRepository <Credential> >()
.To <EntityRepository <Credential> >()
.InRequestScope();
Bind <ICuratedFeedService>()
.To <CuratedFeedService>()
.InRequestScope();
Bind <IUserService>()
.To <UserService>()
.InRequestScope();
Bind <IPackageService>()
.To <PackageService>()
.InRequestScope();
Bind <EditPackageService>().ToSelf();
Bind <IFormsAuthenticationService>()
.To <FormsAuthenticationService>()
.InSingletonScope();
Bind <IControllerFactory>()
.To <NuGetControllerFactory>()
.InRequestScope();
Bind <IIndexingService>()
.To <LuceneIndexingService>()
.InRequestScope();
Bind <INuGetExeDownloaderService>()
.To <NuGetExeDownloaderService>()
.InRequestScope();
var mailSenderThunk = new Lazy <IMailSender>(
() =>
{
var settings = Kernel.Get <ConfigurationService>();
if (settings.Current.SmtpUri != null && settings.Current.SmtpUri.IsAbsoluteUri)
{
var smtpUri = new SmtpUri(settings.Current.SmtpUri);
var mailSenderConfiguration = new MailSenderConfiguration
{
DeliveryMethod = SmtpDeliveryMethod.Network,
Host = smtpUri.Host,
Port = smtpUri.Port,
EnableSsl = smtpUri.Secure
};
if (!String.IsNullOrWhiteSpace(smtpUri.UserName))
{
mailSenderConfiguration.UseDefaultCredentials = false;
mailSenderConfiguration.Credentials = new NetworkCredential(
smtpUri.UserName,
smtpUri.Password);
}
return(new MailSender(mailSenderConfiguration));
}
else
{
var mailSenderConfiguration = new MailSenderConfiguration
{
DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
PickupDirectoryLocation = HostingEnvironment.MapPath("~/App_Data/Mail")
};
return(new MailSender(mailSenderConfiguration));
}
});
Bind <IMailSender>()
.ToMethod(context => mailSenderThunk.Value);
Bind <IMessageService>()
.To <MessageService>();
Bind <IPrincipal>().ToMethod(context => HttpContext.Current.User);
switch (configuration.Current.StorageType)
{
case StorageType.FileSystem:
case StorageType.NotSpecified:
ConfigureForLocalFileSystem();
break;
case StorageType.AzureStorage:
ConfigureForAzureStorage(configuration);
break;
}
Bind <IFileSystemService>()
.To <FileSystemService>()
.InSingletonScope();
Bind <IPackageFileService>()
.To <PackageFileService>();
Bind <IEntityRepository <PackageOwnerRequest> >()
.To <EntityRepository <PackageOwnerRequest> >()
.InRequestScope();
Bind <IUploadFileService>()
.To <UploadFileService>();
// todo: bind all package curators by convention
Bind <IAutomaticPackageCurator>()
.To <WebMatrixPackageCurator>();
Bind <IAutomaticPackageCurator>()
.To <Windows8PackageCurator>();
// todo: bind all commands by convention
Bind <IAutomaticallyCuratePackageCommand>()
.To <AutomaticallyCuratePackageCommand>()
.InRequestScope();
Bind <IAggregateStatsService>()
.To <AggregateStatsService>()
.InRequestScope();
Bind <IPackageIdsQuery>()
.To <PackageIdsQuery>()
.InRequestScope();
Bind <IPackageVersionsQuery>()
.To <PackageVersionsQuery>()
.InRequestScope();
}
