title: CKfinder- Dynamic User folder -Asp.net MVC 5
body: <p>I am using Asp.NET MVC 5 to build a web application. I downloaded Ckeditor and CKfinder Connector for ASP.NET. I was able to follow the instructions and get Ckeditor and Ckfinder integration to work.</p>
  
  <p>I am trying to figure out how I can have dynamic folder directory in CkFinder per logged in user. According to the instructions provided in <a href="http://docs.cksource.com/ckfinder3-net/howto.html#howto_private_folders" rel="nofollow">http://docs.cksource.com/ckfinder3-net/howto.html#howto_private_folders</a> it tells you to do that in connectorBuilder .SetRequestConfiguration. The problem is that ConnectorBuilder is being setup on the startup and the user logs in after that?</p>
  
  <p>Here is the code that i have now where everything works except the icons</p>
  
  <pre class="lang-cs prettyprint-override"><code>using DearColleagueV2.Models;
  
  [assembly: Microsoft.Owin.OwinStartup(typeof(DearColleagueV2.Startup))]
  
  namespace DearColleagueV2
  {
      using System.Configuration;
  
      using CKSource.CKFinder.Connector.Config;
      using CKSource.CKFinder.Connector.Core.Builders;
      using CKSource.CKFinder.Connector.Core.Logs;
      using CKSource.CKFinder.Connector.Host.Owin;
      using CKSource.CKFinder.Connector.Logs.NLog;
      using CKSource.CKFinder.Connector.KeyValue.EntityFramework;
      using CKSource.FileSystem.Dropbox;
      using CKSource.FileSystem.Local;
  
      using System;
      using Microsoft.AspNet.Identity;
      using Microsoft.AspNet.Identity.Owin;
      using Microsoft.Owin;
      using Microsoft.Owin.Security.Cookies;
  
      using Owin;
      using Microsoft.Owin.Security;
      using CKSource.CKFinder.Connector.Core.Acl;
      using System.Collections.Generic;
      using CKSource.CKFinder.Connector.Core.Authentication;
      using System.Threading.Tasks;
      using CKSource.CKFinder.Connector.Core;
      using System.Threading;
      using System.Security.Cryptography;
      using System.Text;
  
      public partial class Startup
      {
          public void Configuration(IAppBuilder builder)
          {
              LoggerManager.LoggerAdapterFactory = new NLogLoggerAdapterFactory();
              ConfigureAuthForIdentity(builder);
  
              RegisterFileSystems();
  
              var connectorBuilder = ConfigureConnector();
              var connector = connectorBuilder.Build(new OwinConnectorFactory());
              builder.Map("/CKFinder/connector", builder1 =&gt; builder1.UseConnector(connector));
          }
  
          private void ConfigureAuthForIdentity(IAppBuilder app)
          {
              // Configure the db context, user manager and signin manager to use a single instance per request
              app.CreatePerOwinContext(ApplicationDbContext.Create);
              app.CreatePerOwinContext&lt;ApplicationUserManager&gt;(ApplicationUserManager.Create);
              app.CreatePerOwinContext&lt;ApplicationSignInManager&gt;(ApplicationSignInManager.Create);
  
              // Enable the application to use a cookie to store information for the signed in user
              // and to use a cookie to temporarily store information about a user logging in with a third party login provider
              // Configure the sign in cookie
              app.UseCookieAuthentication(new CookieAuthenticationOptions
              {
                  AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                  LoginPath = new PathString("/Account/Login"),
                  Provider = new CookieAuthenticationProvider
                  {
                      // Enables the application to validate the security stamp when the user logs in.
                      // This is a security feature which is used when you change a password or add an external login to your account.  
                      OnValidateIdentity = SecurityStampValidator.OnValidateIdentity&lt;ApplicationUserManager, ApplicationUser&gt;(
                          validateInterval: TimeSpan.FromMinutes(30),
                          regenerateIdentity: (manager, user) =&gt; user.GenerateUserIdentityAsync(manager))
                  }
              });
              app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
  
              // Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
              app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));
  
              // Enables the application to remember the second login verification factor such as phone or email.
              // Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
              // This is similar to the RememberMe option when you log in.
              app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);
  
  
          }
  
          public ConnectorBuilder ConfigureConnector()
          {
              var connectorBuilder = new ConnectorBuilder();
              connectorBuilder
                  .SetRequestConfiguration(
                      (request, config) =&gt;
                      {
  
                          //config.AddProxyBackend("local", new LocalStorage(@"MyFiles"));
                          var userName = request.Principal?.Identity?.Name;
                          if (userName != null)
                          {
                              var sha = new SHA1CryptoServiceProvider();
                              var hash = sha.ComputeHash(Encoding.UTF8.GetBytes(userName));
                              var folderName = BitConverter.ToString(hash).Replace("-", string.Empty);
                              config.AddProxyBackend("local", new LocalStorage(@"c:\files"));
                              config.AddResourceType("private", resourceBuilder =&gt; resourceBuilder.SetBackend("local", folderName));
                              config.SetThumbnailBackend("local", "thumbs");                            
                              config.AddAclRule(new AclRule(
                     new StringMatcher("*"), new StringMatcher("/"), new StringMatcher("*"),
                     new Dictionary&lt;Permission, PermissionType&gt;
                     {
                           { Permission.FolderView, PermissionType.Allow },
                           { Permission.FolderCreate, PermissionType.Allow },
                           { Permission.FolderRename, PermissionType.Allow },
                           { Permission.FolderDelete, PermissionType.Allow },
  
                           { Permission.FileView, PermissionType.Allow },
                           { Permission.FileCreate, PermissionType.Allow },
                           { Permission.FileRename, PermissionType.Allow },
                           { Permission.FileDelete, PermissionType.Allow },
  
  
                           { Permission.ImageResize, PermissionType.Allow },
                           { Permission.ImageResizeCustom, PermissionType.Allow }
                     }));
                          }
                      })
                  .SetAuthenticator(new MyAuthenticator());
  
              return connectorBuilder;
          }
  
          private static void RegisterFileSystems()
          {
              FileSystemFactory.RegisterFileSystem&lt;LocalStorage&gt;();
              FileSystemFactory.RegisterFileSystem&lt;DropboxStorage&gt;();
          }
  
      }
  
      public class MyAuthenticator : IAuthenticator
      {
          public Task&lt;CKSource.CKFinder.Connector.Core.Authentication.IUser&gt; AuthenticateAsync(ICommandRequest commandRequest, CancellationToken cancellationToken)
          {
              var user = new User(true, null);
              return Task.FromResult((CKSource.CKFinder.Connector.Core.Authentication.IUser)user);
          }
      }
  }
  </code></pre>