/// <summary>
/// Load settings
/// </summary>
/// <returns></returns>
public virtual DataSettings LoadSettings()
{
string connectionString = ConfigurationManager.ConnectionStrings["HickConnectionString"].ToString();
if (!string.IsNullOrEmpty(connectionString))
{
var DataSettings = new DataSettings();
DataSettings.DataConnectionString = connectionString;
return DataSettings;
}
else
return new DataSettings();
}
public ActionResult RestartInstall()
{
if (DataSettings.DatabaseIsInstalled())
{
return(RedirectToRoute("HomePage"));
}
// Restart application
var webHelper = EngineContext.Current.Resolve <IWebHelper>();
webHelper.RestartAppDomain();
// Redirect to home page
return(RedirectToAction("Index", "Home"));
}
private void RegisterVirtualPathProviders()
{
var vppSystem = HostingEnvironment.VirtualPathProvider;
// register virtual path provider for bundling (Sass & variables handling)
BundleTable.VirtualPathProvider = new BundlingVirtualPathProvider(vppSystem);
if (DataSettings.DatabaseIsInstalled())
{
var vppTheme = new ThemingVirtualPathProvider(vppSystem);
// register virtual path provider for theming (file inheritance handling etc.)
HostingEnvironment.RegisterVirtualPathProvider(vppTheme);
}
}
/// <summary>
/// Returns information about the requested route.
/// </summary>
/// <param name="httpContext">An object that encapsulates information about the HTTP request.</param>
/// <returns>
/// An object that contains the values from the route definition.
/// </returns>
public override RouteData GetRouteData(HttpContextBase httpContext)
{
if (DataSettings.DatabaseIsInstalled() && this.SeoFriendlyUrlsForLanguagesEnabled)
{
var helper = new LocalizedUrlHelper(httpContext.Request);
if (helper.IsLocalizedUrl())
{
helper.StripSeoCode();
httpContext.RewritePath("~/" + helper.RelativePath, true);
}
}
RouteData data = base.GetRouteData(httpContext);
return(data);
}
public void Seed(SmartObjectContext context)
{
context.MigrateLocaleResources(MigrateLocaleResources);
context.SaveChanges();
if (HostingEnvironment.IsHosted && DataSettings.DatabaseIsInstalled())
{
// Import all xml templates on disk
var converter = new MessageTemplateConverter(context);
var language = ResolveMasterLanguage(context);
converter.ImportAll(language);
DropDefaultValueConstraint(context);
}
}
/// <summary>
/// Save data settings to the file
/// </summary>
/// <param name="settings">Data settings</param>
/// <param name="fileProvider">File provider</param>
public static void SaveSettings(DataSettings settings, INopFileProvider fileProvider = null)
{
Singleton <DataSettings> .Instance = settings ?? throw new ArgumentNullException(nameof(settings));
fileProvider = fileProvider ?? CommonHelper.DefaultFileProvider;
var filePath = fileProvider.MapPath(NopDataSettingsDefaults.FilePath);
//create file if not exists
fileProvider.CreateFile(filePath);
//save data settings to the file
var text = JsonConvert.SerializeObject(Singleton <DataSettings> .Instance, Formatting.Indented);
fileProvider.WriteAllText(filePath, text, Encoding.UTF8);
}
public virtual void OnAuthorization(AuthorizationContext filterContext)
{
// don't apply filter to child methods
if (filterContext.IsChildAction)
{
return;
}
// only redirect for GET requests,
// otherwise the browser might not propagate the verb and request body correctly.
if (!string.Equals(filterContext.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
{
return;
}
if (HostingEnvironment.IsHosted && !DataSettings.DatabaseIsInstalled())
{
return;
}
var currentStore = StoreContext.Value.CurrentStore;
var uri = filterContext.HttpContext.Request.Url;
var originalUrl = new Uri(uri.GetLeftPart(UriPartial.Authority) + filterContext.HttpContext.Request.RawUrl);
var rewriteContext = new RewriteContext
{
ControllerContext = filterContext,
OriginalUrl = originalUrl,
IsLoopback = uri.IsLoopback || filterContext.HttpContext.Request.IsLocal,
CurrentStore = currentStore,
SecurityMode = currentStore.GetSecurityMode(),
IsAdmin = WorkContext.Value.IsAdmin
};
// Applies HTTP protocol rule
TryRewriteScheme(rewriteContext);
// Applies canonical host name rule
TryRewriteHostName(rewriteContext);
// Applies trailing slash and lowercase rules
TryRewritePath(rewriteContext);
if (rewriteContext.Url.HasValue())
{
filterContext.Result = new RedirectResult(rewriteContext.Url, rewriteContext.Permanent ?? !rewriteContext.IsLoopback);
}
}
static void Main(String[] args)
{
//using (WebApp.Start<Startup>(url: baseAddress))
//{
//Console.WriteLine(ws.Patch("Category(1)", "{\"Description\":\"test\"}"));
//WebService.Post("UrlRecord", json);
logToAdd = "";
SyncDate = DateTime.Now;
//Turn comma to dot (in doubles) - useful for json format
System.Globalization.CultureInfo customCulture = (System.Globalization.CultureInfo)System.Threading.Thread.CurrentThread.CurrentCulture.Clone();
customCulture.NumberFormat.NumberDecimalSeparator = ".";
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;
//AppDomain.CurrentDomain.ProcessExit += new EventHandler(OnProcessExit);
if (args.Length > 0)
{
Process(args);
}
else
{
DataSettings s = DatabaseIsInstalled();
if (s == null)
{
RunGui(s);
}
else
{
RunCli(args);
}
}
//{
// if (!DatabaseManager.CheckTableExistence("WEB_API_CREDENTIALS"))
// RunInstall();
// else if (!DatabaseManager.CheckTableHasData("WEB_API_CREDENTIALS"))
// RunConfig();
// else
// {
// if (args.Length == 0)
// //Run CLI en mode interactif
// RunCli(args);
// else
// Process(args);
// }
//}
}
public SmartDbConfiguration()
{
// DB model caching
if (HostingEnvironment.IsHosted)
{
var cacheLocation = CommonHelper.MapPath("~/App_Data/EfCache");
System.IO.Directory.CreateDirectory(cacheLocation);
var modelStore = new EfDbModelStore(cacheLocation);
AddDependencyResolver(new SingletonDependencyResolver <DbModelStore>(modelStore));
}
IEfDataProvider provider = null;
try
{
provider = (new EfDataProviderFactory(DataSettings.Current).LoadDataProvider()) as IEfDataProvider;
}
catch
{
/* SmartStore is not installed yet! */
}
if (provider != null)
{
base.SetDefaultConnectionFactory(provider.GetConnectionFactory());
if (HostingEnvironment.IsHosted && DataSettings.DatabaseIsInstalled())
{
Loaded += (sender, args) =>
{
// prepare EntityFramework 2nd level cache
IDbCache cache = null;
try
{
cache = EngineContext.Current.Resolve <IDbCache>();
}
catch
{
cache = new NullDbCache();
}
var cacheInterceptor = new CacheTransactionInterceptor(cache);
AddInterceptor(cacheInterceptor);
args.ReplaceService <DbProviderServices>((s, o) => new CachingProviderServices(s, cacheInterceptor));
};
}
}
}
public DataTable GetDataTable(string _query)
{
DataSettingsManager _dataSettingsManager = new DataSettingsManager();
DataSettings _dataSettings = _dataSettingsManager.LoadSettings();
SqlConnection _sqlConnection = new SqlConnection(_dataSettings.DataConnectionString + ";Connection Timeout=0");
DataTable dt = new DataTable();
if (_sqlConnection.State == ConnectionState.Closed)
{
_sqlConnection.Open();
}
SqlDataAdapter _da = new SqlDataAdapter(_query, _sqlConnection);
_da.Fill(dt);
return(dt);
}
internal AzureCosmosCollection(Container container, DataSettings settings)
{
ChangeSet = new List <HasId>();
Container = container;
Settings = settings;
Options = new QueryRequestOptions {
MaxItemCount = 1000
};
/*Options = new FeedOptions {
* EnableCrossPartitionQuery = true,
* MaxItemCount = 1000,
* MaxDegreeOfParallelism = 16
* };*/
}
public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
{
//Load custom data settings
var dataSettingsManager = new DataSettingsManager();
DataSettings dataSettings = dataSettingsManager.LoadSettings();
//Register custom object context
builder.Register <IDbContext>(c => RegisterIDbContext(c, dataSettings)).Named <IDbContext>(CONTEXT_NAME).InstancePerHttpRequest();
builder.Register(c => RegisterIDbContext(c, dataSettings)).InstancePerHttpRequest();
//Register services
builder.RegisterType <SagePayServerTransactionService>().As <ISagePayServerTransactionService>();
//Override the repository injection
builder.RegisterType <EfRepository <SagePayServerTransaction> >().As <IRepository <SagePayServerTransaction> >().WithParameter(ResolvedParameter.ForNamed <IDbContext>(CONTEXT_NAME)).InstancePerHttpRequest();
}
public override void Up()
{
int entityId = 0;
if (DataSettings.DatabaseIsInstalled() && HostingEnvironment.IsHosted)
{
var ctx = new SmartObjectContext();
entityId = ctx.Set <Product>().Select(x => x.Id).FirstOrDefault();
}
AddColumn("dbo.Download", "EntityId", c => c.Int(nullable: false, defaultValue: entityId));
AddColumn("dbo.Download", "EntityName", c => c.String(nullable: false, maxLength: 100));
AddColumn("dbo.Download", "FileVersion", c => c.String(maxLength: 30));
AddColumn("dbo.Download", "Changelog", c => c.String());
CreateIndex("dbo.Download", new[] { "EntityId", "EntityName" });
}
private void TryConfigureDbAppender(ILoggerRepository repository)
{
if (repository == null || !DataSettings.DatabaseIsInstalled())
{
return;
}
var adoNetAppenders = repository.GetAppenders().OfType <AdoNetAppender>().Where(x => x.Name == "database").ToList();
foreach (var appender in adoNetAppenders)
{
appender.ConnectionString = DataSettings.Current.DataConnectionString;
appender.ConnectionType = DataSettings.Current.DataConnectionType;
appender.ActivateOptions();
}
}
public override void Down()
{
var defaultLanguageId = 1;
if (DataSettings.DatabaseIsInstalled())
{
defaultLanguageId = new SmartObjectContext().Set <Language>().Select(x => x.Id).FirstOrDefault();
}
AddColumn("dbo.News", "LanguageId", c => c.Int(nullable: false, defaultValue: defaultLanguageId));
AddColumn("dbo.BlogPost", "LanguageId", c => c.Int(nullable: false, defaultValue: defaultLanguageId));
CreateIndex("dbo.News", "LanguageId");
CreateIndex("dbo.BlogPost", "LanguageId");
AddForeignKey("dbo.News", "LanguageId", "dbo.Language", "Id", cascadeDelete: true);
AddForeignKey("dbo.BlogPost", "LanguageId", "dbo.Language", "Id", cascadeDelete: true);
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
if (filterContext == null || filterContext.HttpContext == null)
{
return;
}
HttpRequestBase request = filterContext.HttpContext.Request;
if (request == null)
{
return;
}
//don't apply filter to child methods
if (filterContext.IsChildAction)
{
return;
}
string actionName = filterContext.ActionDescriptor.ActionName;
if (String.IsNullOrEmpty(actionName))
{
return;
}
string controllerName = filterContext.Controller.ToString();
if (String.IsNullOrEmpty(controllerName))
{
return;
}
if (!DataSettings.DatabaseIsInstalled())
{
return;
}
var permissionService = PermissionService.Value;
var publicStoreAllowNavigation = permissionService.Authorize(StandardPermissionProvider.PublicStoreAllowNavigation);
if (!publicStoreAllowNavigation && !IsPermittedRoute(controllerName, actionName))
{
filterContext.Result = new HttpUnauthorizedResult();
}
}
public void OnActionExecuted(ActionExecutedContext filterContext)
{
if (!DataSettings.DatabaseIsInstalled())
{
return;
}
if (filterContext == null || filterContext.HttpContext == null || filterContext.HttpContext.Request == null)
{
return;
}
// don't apply filter to child methods
if (filterContext.IsChildAction)
{
return;
}
// handle JsonResult only
if (filterContext.Result.GetType() != typeof(JsonResult))
{
return;
}
var jsonResult = filterContext.Result as JsonResult;
var settings = new JsonSerializerSettings
{
MissingMemberHandling = MissingMemberHandling.Ignore,
TypeNameHandling = TypeNameHandling.Objects,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
// We cannot ignore null. Client template of several Telerik grids would fail.
//NullValueHandling = NullValueHandling.Ignore,
MaxDepth = 32
};
filterContext.Result = new JsonNetResult(DateTimeHelper.Value, settings)
{
Data = jsonResult.Data,
ContentType = jsonResult.ContentType,
ContentEncoding = jsonResult.ContentEncoding,
JsonRequestBehavior = jsonResult.JsonRequestBehavior,
MaxJsonLength = jsonResult.MaxJsonLength,
RecursionLimit = jsonResult.RecursionLimit
};
}
protected Task ScanForServiceRegistryContainers()
{
return(Task.Run(() =>
{
try
{
DirectoryInfo entryDir = Assembly.GetEntryAssembly().GetFileInfo().Directory;
DirectoryInfo sysAssemblies = DataSettings.GetSysAssemblyDirectory();
DirectoryInfo[] dirs = new DirectoryInfo[] { entryDir, sysAssemblies };
string[] searchPatterns = AssemblySearchPattern.DelimitSplit(",", true);
List <FileInfo> files = searchPatterns.SelectMany(searchPattern =>
{
List <FileInfo> tmp = new List <FileInfo>();
foreach (DirectoryInfo dir in dirs)
{
if (dir.Exists)
{
tmp.AddRange(dir.GetFiles(searchPattern));
}
}
return tmp;
}).ToList();
_scanResults.Clear();
Parallel.ForEach(files, file =>
{
try
{
Assembly assembly = Assembly.LoadFile(file.FullName);
foreach (Type type in assembly.GetTypes().Where(t => t.HasCustomAttributeOfType <ServiceRegistryContainerAttribute>()))
{
_scanResults.Add(type, RegisterServiceRegistryContainer(type));
}
}
catch (Exception ex)
{
Logger.AddEntry("Exception scanning for ServiceRegistries in file ({0})", ex, file.FullName);
}
});
}
catch (Exception ex)
{
Logger.AddEntry("Exception occurred scanning for service registry containers: {0}", ex, ex.Message);
}
}));
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <NullChronometer>().As <IChronometer>().SingleInstance();
builder.RegisterType <Log4netLoggerFactory>().As <ILoggerFactory>().SingleInstance();
// call GetLogger in response to the request for an ILogger implementation
if (DataSettings.DatabaseIsInstalled())
{
builder.Register(GetContextualLogger).As <ILogger>().ExternallyOwned();
}
else
{
// the install logger should append to a rolling text file only.
builder.Register(GetInstallLogger).As <ILogger>().ExternallyOwned();
}
}
private bool IsThemeableRequest()
{
if (!DataSettings.DatabaseIsInstalled())
{
return(false);
}
else
{
var webHelper = EngineContext.Current.Resolve <IWebHelper>();
var requestUrl = webHelper.GetThisPageUrl(false);
string themeUrl = string.Format("{0}themes", webHelper.GetStoreLocation());
var isThemeableRequest = requestUrl.StartsWith(themeUrl + "/", StringComparison.InvariantCultureIgnoreCase);
return(isThemeableRequest);
}
}
protected override void DeleteThumbnailImageInternal(Document doc)
{
using (IDbConnection connection = DataSettings.GetConnection())
using (IDbCommand command = connection.CreateCommand()) {
command.CommandText =
@"UPDATE Files SET Thumbnail = NULL WHERE DocNum = ?DocNum";
IDataParameter docNumParameter = command.CreateParameter();
docNumParameter.ParameterName = "DocNum";
docNumParameter.Value = doc.DocNum;
command.Parameters.Add(docNumParameter);
connection.Open();
command.ExecuteNonQuery();
connection.Close();
}
}
private async void btnRemoveCategory_ClickedAsync(object sender, EventArgs e)
{
if (pickerCategory.SelectedIndex != -1)
{
var answer = await DisplayAlert(Panda_Kakei.Resources.AppResource.RemoveText,
Panda_Kakei.Resources.AppResource.DialogRemoveText, Panda_Kakei.Resources.AppResource.YesText,
Panda_Kakei.Resources.AppResource.NoText);
// Answer is yes, delete
if (answer == true)
{
DataSettings deleteCategory = (DataSettings)pickerCategory.SelectedItem;
SharedObject.dbManager.DeleteSettingsItem(deleteCategory);
loadCategoriesFromDB();
}
}
}
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, bool isActiveModule)
{
builder.RegisterType <ProfilerService>().As <IProfilerService>().InstancePerRequest();
if (isActiveModule && DataSettings.DatabaseIsInstalled())
{
// intercept ALL public store controller actions
builder.RegisterType <ProfilerFilter>().AsActionFilterFor <SmartController>();
builder.RegisterType <WidgetZoneFilter>().AsActionFilterFor <SmartController>();
//// intercept CatalogController's Product action
//builder.RegisterType<SampleResultFilter>().AsResultFilterFor<CatalogController>(x => x.Product(default(int), default(string))).InstancePerRequest();
//builder.RegisterType<SampleActionFilter>().AsActionFilterFor<PublicControllerBase>().InstancePerRequest();
//// intercept CheckoutController's Index action (to hijack the checkout or payment workflow)
//builder.RegisterType<SampleCheckoutFilter>().AsActionFilterFor<CheckoutController>(x => x.Index()).InstancePerRequest();
}
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <DbLogService>().As <IDbLogService>().InstancePerLifetimeScope();
builder.RegisterType <ActivityLogger>().As <IActivityLogger>().InstancePerLifetimeScope();
builder.RegisterType <Notifier>().As <INotifier>().InstancePerLifetimeScope();
// Call GetLogger in response to the request for an ILogger implementation
if (DataSettings.DatabaseIsInstalled())
{
builder.Register(GetContextualLogger).As <ILogger>().ExternallyOwned();
}
else
{
// The install logger should append to a rolling text file only.
builder.Register(GetInstallLogger).As <ILogger>().ExternallyOwned();
}
}
public void AnonymousIdentification_Creating(object sender, AnonymousIdentificationEventArgs args)
{
try
{
if (DataSettings.DatabaseIsInstalled())
{
var customerService = EngineContext.Current.Resolve <ICustomerService>();
var customer = customerService.FindGuestCustomerByClientIdent(maxAgeSeconds: 180);
if (customer != null)
{
// We found our anonymous visitor: don't let ASP.NET create a new id.
args.AnonymousID = customer.CustomerGuid.ToString();
}
}
}
catch { }
}
private FloorPackRecordObjectContext RegisterIDbContext(
IComponentContext componentContext, DataSettings dataSettings)
{
string dataConnectionStrings;
if (dataSettings != null && dataSettings.IsValid())
{
dataConnectionStrings = dataSettings.DataConnectionString;
}
else
{
dataConnectionStrings =
componentContext.Resolve <DataSettings>().DataConnectionString;
}
return(new FloorPackRecordObjectContext(dataConnectionStrings));
}
public AzureCosmosDbProvider(DataSettings settings)
{
Settings = settings;
ForceCamelcase = true;
Client = new CosmosClient(settings.Uri, settings.Key, new CosmosClientOptions {
ConnectionMode = ConnectionMode.Direct
});
Database = Client.GetDatabase(settings.Database);
SerializerSettings = new JsonSerializerSettings {
ContractResolver = new DocumentContractResolver()
};
DefaultCollection = GetCollectionAsync(settings.Container).Result;
}
protected override void DeleteDocument(Document doc)
{
using (IDbConnection connection = DataSettings.GetConnection())
using (IDbCommand command = connection.CreateCommand()) {
command.CommandText =
@"DELETE FROM files WHERE DocNum = ?DocNum";
IDataParameter docNumParameter = command.CreateParameter();
docNumParameter.ParameterName = "DocNum";
docNumParameter.Value = doc.DocNum;
command.Parameters.Add(docNumParameter);
connection.Open();
command.ExecuteNonQuery();
connection.Close();
}
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
if (!DataSettings.DatabaseIsInstalled())
{
return;
}
if (filterContext == null || filterContext.HttpContext == null || filterContext.HttpContext.Request == null)
{
return;
}
//don't apply filter to child methods
if (filterContext.IsChildAction)
{
return;
}
//only GET requests
if (!String.Equals(filterContext.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
{
return;
}
var customerSettings = EngineContext.Current.Resolve <CustomerSettings>();
if (!customerSettings.StoreLastVisitedPage)
{
return;
}
var webHelper = EngineContext.Current.Resolve <IWebHelper>();
var pageUrl = webHelper.GetThisPageUrl(true);
if (!String.IsNullOrEmpty(pageUrl))
{
var workContext = EngineContext.Current.Resolve <IWorkContext>();
var genericAttributeService = EngineContext.Current.Resolve <IGenericAttributeService>();
var previousPageUrl = workContext.CurrentCustomer.GetAttribute <string>(SystemCustomerAttributeNames.LastVisitedPage);
if (!pageUrl.Equals(previousPageUrl))
{
genericAttributeService.SaveAttribute(workContext.CurrentCustomer, SystemCustomerAttributeNames.LastVisitedPage, pageUrl);
}
}
}
protected override void Load(ContainerBuilder builder)
{
// Utils
builder.RegisterType <MediaMigrator>().InstancePerRequest();
builder.RegisterType <MediaMigrator3>().InstancePerRequest();
builder.RegisterType <MediaHelper>().InstancePerRequest();
builder.RegisterType <MediaExceptionFactory>().InstancePerRequest();
builder.RegisterType <MediaTypeResolver>().As <IMediaTypeResolver>().InstancePerRequest();
builder.RegisterType <MediaUrlGenerator>().As <IMediaUrlGenerator>().InstancePerRequest();
builder.RegisterType <AlbumRegistry>().As <IAlbumRegistry>().InstancePerRequest();
builder.RegisterType <FolderService>().As <IFolderService>().InstancePerRequest();
builder.RegisterType <MediaTracker>().As <IMediaTracker>().InstancePerRequest();
builder.RegisterType <MediaSearcher>().As <IMediaSearcher>().InstancePerRequest();
builder.RegisterType <MediaService>().As <IMediaService>().InstancePerRequest();
builder.RegisterType <DownloadService>().As <IDownloadService>().InstancePerRequest();
// ImageProcessor adapter factory
builder.RegisterType <IPImageFactory>().As <IImageFactory>().SingleInstance();
builder.RegisterType <ImageCache>().As <IImageCache>().InstancePerRequest();
builder.RegisterType <DefaultImageProcessor>().As <IImageProcessor>().InstancePerRequest();
builder.RegisterType <MediaMover>().As <IMediaMover>().InstancePerRequest();
// Register factory for currently active media storage provider
if (DataSettings.DatabaseIsInstalled())
{
builder.Register(MediaStorageProviderFactory);
}
else
{
builder.Register <Func <IMediaStorageProvider> >(c => () => new FileSystemMediaStorageProvider(new MediaFileSystem()));
}
// Register all album providers
var albumProviderTypes = _typeFinder.FindClassesOfType <IAlbumProvider>(ignoreInactivePlugins: true);
foreach (var type in albumProviderTypes)
{
builder.RegisterType(type).As <IAlbumProvider>().Keyed <IAlbumProvider>(type).InstancePerRequest();
}
// Handlers
builder.RegisterType <ImageHandler>().As <IMediaHandler>().InstancePerRequest();
}
protected override void AttachToComponentRegistration(IComponentRegistryBuilder componentRegistry, IComponentRegistration registration)
{
if (!DataSettings.DatabaseIsInstalled())
{
return;
}
var userProperty = FindUserProperty(registration.Activator.LimitType);
if (userProperty == null)
{
return;
}
registration.Metadata.Add("Property.T", FastProperty.Create(userProperty));
registration.PipelineBuilding += (sender, pipeline) =>
{
// Add our Localizer middleware to the pipeline.
pipeline.Use(PipelinePhase.ParameterSelection, (context, next) =>
{
next(context);
if (!context.NewInstanceActivated || context.Registration.Metadata.Get("Property.T") is not FastProperty prop)
{
return;
}
try
{
var iText = context.Resolve <IText>();
if (prop.Property.PropertyType == typeof(Localizer))
{
Localizer localizer = context.Resolve <IText>().Get;
prop.SetValue(context.Instance, localizer);
}
else
{
LocalizerEx localizerEx = context.Resolve <IText>().GetEx;
prop.SetValue(context.Instance, localizerEx);
}
}
catch { }
});
};
public EfDataProviderManager(DataSettings settings)
: base(settings)
{
}
