public JsonResult AuthenticateUser(LoginModel loginModel)
{
_securityDataProvider = new SecurityDataProvider();
ServiceResponse response = _securityDataProvider.AuthenticateUser(loginModel, false);
if (response.IsSuccess)
{
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(1,
loginModel.Email,
DateTime.Now,
DateTime.Now.AddMinutes(Constants.RememberMeDuration),
true,
loginModel.Email,
FormsAuthentication.FormsCookiePath
);
string encTicket = FormsAuthentication.Encrypt(ticket);
// Create the cookie.
HttpCookie httpCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket)
{
Expires = ticket.Expiration
};
Response.Cookies.Add(httpCookie);
SessionValueData sessiondata = (SessionValueData)response.Data;
SessionHelper.UserId = sessiondata.UserId;
SessionHelper.UserRoleId = sessiondata.UserRoleId;
SessionHelper.CurrentUser = sessiondata.CurrentUser;
}
;
return(Json(response));
}
} // UserId --> list of ContainerIds
internal static SecurityCache Initialize(ISecurityDataProvider dataProvider)
{
var cache = new SecurityCache();
cache.Load(dataProvider);
return(cache);
}
internal void Load(ISecurityDataProvider dataProvider)
{
var entities = DataHandler.LoadSecurityEntities(dataProvider);
var aclTable = DataHandler.LoadAcls(dataProvider, entities);
BuildAcls(entities, aclTable);
this.Entities = entities;
this.Groups = DataHandler.LoadAllGroups(dataProvider);
this.Membership = FlattenUserMembership(this.Groups);
}
internal static void StartTheSystem(ISecurityDataProvider securityDataProvider)
{
MessageSender.Initialize("asdf");
// Call SecurityContext starter method.
SecurityContextForConcurrencyTests.StartTheSystem(new SecurityConfiguration
{
SecurityDataProvider = securityDataProvider,
MessageProvider = new DefaultMessageProvider(),
CommunicationMonitorRunningPeriodInSeconds = 31,
});
}
/// <summary>
/// Building and connecting necessary LEGO bricks.
/// One of the possible comfortable solution. Every component is stateless so we can be stored for long time.
/// </summary>
public static void StartTheSystem(ISecurityDataProvider securityDataProvider)
{
// Get configured or default messaging component and initialize it.
var messageProvider = ResolveMessageProvider();
messageProvider.Initialize();
MessageSender.Initialize(messageProvider.ReceiverName);
// call the second step
Debug.WriteLine("SECU> StartTheSystem: " + securityDataProvider.GetType().Name);
StartTheSystem(securityDataProvider, messageProvider);
}
//==============================================================================================
internal static Messaging.CompletionState LoadCompletionState(ISecurityDataProvider dataProvider, out int lastDatabaseId)
{
var ids = dataProvider.GetUnprocessedActivityIds();
lastDatabaseId = ids.LastOrDefault();
var result = new Messaging.CompletionState();
// there is no unprocessed: last item is the last database id
if (ids.Length <= 1)
{
result.LastActivityId = lastDatabaseId;
return(result);
}
// there is only one unprocessed element
if (ids.Length == 2)
{
result.LastActivityId = lastDatabaseId;
result.Gaps = new[] { ids[ids.Length - 2] };
return(result);
}
// if last unprocessed and last database id does not equal,
// each item is gap
if (lastDatabaseId != ids[ids.Length - 2])
{
// i-2 -1
// _,_,3,_,_,6,_,8,9,10,11 ,12
result.LastActivityId = lastDatabaseId;
result.Gaps = ids.Take(ids.Length - 1).ToArray();
return(result);
}
// i-2 -1
// _,_,3,_,_,6,_,8,9,10,11,12 ,12
var continuousFrom = 0;
for (var i = ids.Length - 2; i >= 1; i--)
{
if (ids[i] != ids[i - 1] + 1)
{
continuousFrom = i;
break;
}
}
result.LastActivityId = ids[continuousFrom] - 1;
result.Gaps = ids.Take(continuousFrom).ToArray();
return(result);
}
// Called by tests. The messageProvider must be initialized.
internal static SecuritySystem StartTheSystem(ISecurityDataProvider securityDataProvider, IMessageProvider messageProvider, TextWriter traceChannel = null)
{
var securitySystem = new SecuritySystem(securityDataProvider, messageProvider,
new MissingEntityHandler(),
new SecurityConfiguration(),
new MessagingOptions {
CommunicationMonitorRunningPeriodInSeconds = 31
});
securitySystem.Start();
return(securitySystem);
}
//UNDONE: get configuration through IOptions and register SecuritySystem as a service.
public SecuritySystem(ISecurityDataProvider dataProvider, IMessageProvider messageProvider,
IMissingEntityHandler missingEntityHandler, SecurityConfiguration configuration, MessagingOptions messagingOptions)
{
Configuration = configuration;
MessagingOptions = messagingOptions;
dataProvider.ActivitySerializer = new ActivitySerializer(this);
DataHandler = new DataHandler(dataProvider, Options.Create(messagingOptions));
ActivityHistory = new SecurityActivityHistoryController();
DataProvider = dataProvider;
MessageProvider = messageProvider;
MessageSenderManager = messageProvider.MessageSenderManager;
MissingEntityHandler = missingEntityHandler;
SystemUser = new SecuritySystemUser(configuration.SystemUserId);
}
public static IDictionary <int, SecurityEntity> LoadSecurityEntities_3(ISecurityDataProvider dataProvider)
{
var timer = Stopwatch.StartNew();
var count = dataProvider.GetEstimatedEntityCount();
var capacity = count + count / 10;
var entities = new Dictionary <int, SecurityEntity>(capacity);
var relations = new List <Tuple <SecurityEntity, int> >(capacity); // first is Id, second is ParentId
foreach (var storedEntity in dataProvider.LoadSecurityEntities())
{
var entity = new SecurityEntity
{
Id = storedEntity.Id,
IsInherited = storedEntity.IsInherited,
OwnerId = storedEntity.OwnerId
};
entities.Add(entity.Id, entity);
// memorize relations
if (storedEntity.ParentId != default(int))
{
//entity.Parent = entities[storedEntity.ParentId];
relations.Add(new Tuple <SecurityEntity, int>(entity, storedEntity.ParentId));
}
}
_log.Append("Load: ").Append(timer.Elapsed).Append(", ");
timer.Stop();
timer = Stopwatch.StartNew();
// set parent/child relationship
foreach (var rel in relations)
{
var parentEntity = entities[rel.Item2];
rel.Item1.Parent = parentEntity;
parentEntity.AddChild_Unsafe(rel.Item1);
}
_log.Append("Rel:").Append(timer.Elapsed).Append(", ");
timer.Stop();
timer = Stopwatch.StartNew();
var result = new ConcurrentDictionary <int, SecurityEntity>(entities);
_log.Append("Copy:").Append(timer.Elapsed);
return(result);
}
// Called by tests. The messageProvider must be initialized.
internal static void StartTheSystem(ISecurityDataProvider securityDataProvider, IMessageProvider messageProvider, TextWriter traceChannel = null)
{
// Timestamp of the starting.
var startingThesystem = DateTime.UtcNow;
// Call SecurityContext starter method.
TestSecurityContext.StartTheSystem(new SecurityConfiguration
{
SecurityDataProvider = securityDataProvider,
MessageProvider = messageProvider,
CommunicationMonitorRunningPeriodInSeconds = 31,
});
// Staring message system. Messages before 'startingThesystem' will be ignored.
messageProvider.Start(startingThesystem);
}
/// <summary>
/// Initializes a new instance of the SecurityActivityExecutionLock
/// </summary>
/// <param name="activity">Activity that is locked.</param>
/// <param name="dataProvider">An ISecurityDataProvider instance that need to be called in the Refresh and Release methods.</param>
/// <param name="fullExecutionEnabled">If true, all activity operation must be executed:
/// storing, distributing, applying in the memory. Otherwise only the memory operations are allowed.</param>
public SecurityActivityExecutionLock(SecurityActivity activity, ISecurityDataProvider dataProvider, bool fullExecutionEnabled)
{
_activity = activity;
_dataProvider = dataProvider;
FullExecutionEnabled = fullExecutionEnabled;
var interval = Configuration.Messaging.SecurityActivityExecutionLockRefreshPeriodInSeconds * 1000.0;
_timer = new Timer(interval)
{
Enabled = true
};
_timer.Elapsed += Refresh;
_timer.Disposed += Refresh;
}
public void Initialize()
{
Mock <ISecurityDataProvider> mock = new Mock <ISecurityDataProvider>();
securityDataProvider = mock.Object;
securityController = new SecurityController(securityDataProvider);
var roles = new List <RoleSecurityModel>();
var permission = new List <UserPermissionModel>();
permission.Add(new UserPermissionModel()
{
PermissionID = 1,
PermissionName = "Create"
});
roles.Add(new RoleSecurityModel()
{
ModuleID = 1,
ModuleName = "Registration",
ComponentID = 1,
ComponentName = "Demography",
ModulePermissions = permission
});
var allRoleSeurity = new Response <RoleSecurityModel>()
{
DataItems = roles
};
//Get User Role Security
mock.Setup(r => r.GetUserRoleSecurity(It.IsAny <int>())).Returns(allRoleSeurity);
var rolePermissionResult = new List <ScalarResult <bool> >();
rolePermissionResult.Add(new ScalarResult <bool>()
{
Result = true
});
mock.Setup(r => r.VerifyRolePermission(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(new Response <ScalarResult <bool> >()
{
DataItems = rolePermissionResult
});
}
public static Dictionary <int, AclInfo> LoadAcls(ISecurityDataProvider dataProvider, IDictionary <int, SecurityEntity> entities)
{
var acls = new Dictionary <int, AclInfo>();
foreach (var storedAce in dataProvider.LoadAllAces())
{
AclInfo acl;
if (!acls.TryGetValue(storedAce.EntityId, out acl))
{
acl = new AclInfo(storedAce.EntityId);
acls.Add(acl.EntityId, acl);
}
acl.Entries.Add(new AceInfo {
IdentityId = storedAce.IdentityId, LocalOnly = storedAce.LocalOnly, AllowBits = storedAce.AllowBits, DenyBits = storedAce.DenyBits
});
}
return(acls);
}
public JsonResult Login(LoginModel login)
{
_securityDataProvider = new SecurityDataProvider();
ServiceResponse response = _securityDataProvider.CheckLogin(login, false);
if (response.IsSuccess)
{
if (login.IsRemember)
{
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(1,
login.Email,
DateTime.Now,
DateTime.Now.AddMinutes(
ConfigSettings
.RememberMeDuration),
true,
login.Email,
FormsAuthentication.FormsCookiePath);
// Encrypt the ticket.
string encTicket = FormsAuthentication.Encrypt(ticket);
// Create the cookie.
HttpCookie httpCookie = new HttpCookie(FormsAuthentication.FormsCookieName,
encTicket)
{
Expires = ticket.Expiration
};
Response.Cookies.Add(httpCookie);
}
else
{
FormsAuthentication.SetAuthCookie(login.Email, false);
}
SessionValueData sessionValue = (SessionValueData)response.Data;
SessionHelper.UserID = sessionValue.UserID;
SessionHelper.Name = sessionValue.Name;
SessionHelper.FirstName = sessionValue.FirstName;
SessionHelper.Roles = sessionValue.Roles;
SessionHelper.SelectedRole = sessionValue.SelectedRole;
}
return Json(response);
}
private static void SavePermissions(ISecurityDataProvider db, string tempFolderPath)
{
using (var writer = new StreamWriter(Path.Combine(tempFolderPath, "permissions.txt"), false, Encoding.UTF8))
{
var breaks = db.LoadSecurityEntities()
.Where(e => !e.IsInherited)
.Select(e => e.Id)
.ToArray();
var aces = db.LoadAllAces()
.OrderBy(a => a.EntityId)
.ThenBy(e => e.IdentityId);
foreach (var ace in aces)
{
writer.WriteLine(" \"{0}{1}\",",
breaks.Contains(ace.EntityId) ? "-" : "+",
ace.ToString().Replace("(", "").Replace(")", ""));
}
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IHostApplicationLifetime appLifetime,
ISecurityDataProvider securityDataProvider,
IMessageProvider messageProvider,
IMissingEntityHandler missingEntityHandler,
IOptions <MessagingOptions> messagingOptions)
{
// This will set the global SnLog and SnTrace instances to route log messages to the
// official .Net Core ILogger API.
app.ApplicationServices.AddSenseNetILogger();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGrpcService <SearchService>();
endpoints.MapGet("/", async context =>
{
await context.Response.WriteAsync("Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
});
});
// [sensenet] Start and stop the search service in the appropriate points
// of the application life cycle.
appLifetime.ApplicationStarted.Register(() =>
{
// set the index directory manually based on the current environment
Index.SearchService.Start(
securityDataProvider, messageProvider, missingEntityHandler, messagingOptions.Value,
Path.Combine(Environment.CurrentDirectory, "App_Data", "LocalIndex"));
});
appLifetime.ApplicationStopping.Register(Index.SearchService.ShutDown);
}
/// <summary>
/// Starts the security subsystem using the passed configuration.
/// Call this method only once in your application's startup sequence.
/// The method prepares and memorizes the main components for
/// creating SecurityContext instances in a fastest possible way.
/// The main components are global objects:
/// ISecurityDataProvider instance, IMessageProvider instance and SecurityCache instance.
/// </summary>
protected static void StartTheSystem(SecurityConfiguration configuration)
{
_generalContext = null;
// The messageprovider provider must receive ongoing activities at this time.
StartedAt = DateTime.UtcNow;
int lastActivityIdFromDb;
var uncompleted = DataHandler.LoadCompletionState(configuration.SecurityDataProvider, out lastActivityIdFromDb);
_messageProvider = configuration.MessageProvider;
_messageProvider.MessageReceived += MessageProvider_MessageReceived;
Configuration.Identities.SystemUserId = configuration.SystemUserId ?? -1;
Configuration.Identities.VisitorUserId = configuration.VisitorUserId ?? 6;
Configuration.Identities.EveryoneGroupId = configuration.EveryoneGroupId ?? 8;
Configuration.Identities.OwnerGroupId = configuration.OwnerGroupId ?? 9;
Configuration.Messaging.CommunicationMonitorRunningPeriodInSeconds = configuration.CommunicationMonitorRunningPeriodInSeconds ?? 30;
Configuration.Messaging.SecuritActivityLifetimeInMinutes = configuration.SecuritActivityLifetimeInMinutes ?? 42;
Configuration.Messaging.SecuritActivityTimeoutInSeconds = configuration.SecuritActivityTimeoutInSeconds ?? 120;
_securityDataProviderPrototype = configuration.SecurityDataProvider;
PermissionTypeBase.InferForcedRelations();
using (var op = SnTrace.Security.StartOperation("Security initial loading."))
{
_cacheHolder = SecurityCache.Initialize(configuration.SecurityDataProvider);
op.Successful = true;
}
CommunicationMonitor.Initialize();
_generalContext = new SecurityContext(SystemUser);
SecurityActivityQueue.Startup(uncompleted, lastActivityIdFromDb);
_killed = false;
}
public static void Start(
ISecurityDataProvider securityDataProvider,
IMessageProvider messageProvider,
IMissingEntityHandler missingEntityHandler,
MessagingOptions messagingOptions,
string indexDirectoryPath)
{
UpdateTraceCategories();
// Set index directory before touching the SearchManager class, so that the value
// comes from the application above instead of an automatism in this library.
if (!string.IsNullOrEmpty(indexDirectoryPath))
{
SenseNet.Configuration.Indexing.IndexDirectoryFullPath = indexDirectoryPath;
}
_securitySystem = SecurityHandler.StartSecurity(securityDataProvider, messageProvider, missingEntityHandler, messagingOptions);
using (var traceWriter = new TraceTextWriter())
{
SearchManager.Instance.Start(traceWriter);
}
}
public static IDictionary <int, SecurityEntity> LoadSecurityEntities(ISecurityDataProvider dataProvider)
{
var count = dataProvider.GetEstimatedEntityCount();
var capacity = count + count / 10;
var entities = new Dictionary <int, SecurityEntity>(capacity);
var relations = new List <Tuple <SecurityEntity, int> >(capacity); // first is Id, second is ParentId
foreach (var storedEntity in dataProvider.LoadSecurityEntities())
{
var entity = new SecurityEntity
{
Id = storedEntity.Id,
IsInherited = storedEntity.IsInherited,
OwnerId = storedEntity.OwnerId
};
entities.Add(entity.Id, entity);
// memorize relations
if (storedEntity.ParentId != default(int))
{
relations.Add(new Tuple <SecurityEntity, int>(entity, storedEntity.ParentId));
}
}
// set parent/child relationship
foreach (var rel in relations)
{
var parentEntity = entities[rel.Item2];
rel.Item1.Parent = parentEntity;
parentEntity.AddChild_Unsafe(rel.Item1);
}
return(new ConcurrentDictionary <int, SecurityEntity>(entities));
}
public JoinGroupCommandHandler(IRepository repository, ISecurityDataProvider securityDataProvider, IConfiguration configuration)
{
_repository = repository;
_securityDataProvider = securityDataProvider;
_configuration = configuration;
}
public TwitterService(ITwitterProvider twitterProvider, IAuthService authService, IBitlyService bitlyService, ISecurityDataProvider securityDataProvider)
: this(twitterProvider, authService, securityDataProvider)
{
_bitlyService = bitlyService ?? throw new ArgumentNullException(nameof(bitlyService));
}
public static StoredSecurityEntity GetStoredSecurityEntity(ISecurityDataProvider dataProvider, int entityId)
{
return(dataProvider.LoadStoredSecurityEntity(entityId));
}
public GetMessageOfGroupQueryHandler(ISecurityDataProvider securityDataProvider, IRepository repository)
{
_securityDataProvider = securityDataProvider;
_repository = repository;
}
public static IDictionary <int, SecurityGroup> LoadAllGroups(ISecurityDataProvider dataProvider)
{
var groups = dataProvider.LoadAllGroups();
return(groups.ToDictionary(x => x.Id));
}
public GetAllGroupQueryHandler(IRepository repository,
ISecurityDataProvider securityDataProvider)
{
_repository = repository;
_securityDataProvider = securityDataProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="SecurityController"/> class.
/// </summary>
/// <param name="securityDataProvider">The security data provider.</param>
public SecurityController(ISecurityDataProvider securityDataProvider)
{
this.securityDataProvider = securityDataProvider;
}
public TwitterService(ITwitterProvider twitterProvider, IAuthService authService, ISecurityDataProvider securityDataProvider)
{
_twitterProvider = twitterProvider ?? throw new ArgumentNullException(nameof(twitterProvider));
_authService = authService ?? throw new ArgumentNullException(nameof(authService));
_securityDataProvider = securityDataProvider ?? throw new ArgumentNullException(nameof(securityDataProvider));
}
/// <summary>
/// Sets the security data provider used for all security db operations in the system.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="securityDataProvider">ISecurityDataProvider instance.</param>
public static IRepositoryBuilder UseSecurityDataProvider(this IRepositoryBuilder repositoryBuilder, ISecurityDataProvider securityDataProvider)
{
Configuration.Providers.Instance.SecurityDataProvider = securityDataProvider;
WriteLog("SecurityDataProvider", securityDataProvider);
return(repositoryBuilder);
}
/// <summary>
/// Sets the security data provider used for all security db operations in the system.
/// </summary>
/// <param name="securityDataProvider">ISecurityDataProvider instance.</param>
public RepositoryBuilder UseSecurityDataProvider(ISecurityDataProvider securityDataProvider)
{
Configuration.Providers.Instance.SecurityDataProvider = securityDataProvider;
return(this);
}
public SendMessageToGroupCommandHandler(IRepository repository, ISecurityDataProvider securityDataProvider)
{
_repository = repository;
_securityDataProvider = securityDataProvider;
}
internal void Reset(ISecurityDataProvider dataProvider)
{
Load(dataProvider);
}
