public static void CheckAuthorization(string areaName, string controllerName, string actionName, string username, bool isAuthenticated)
{
// validate the call using the extensibility information (modules, tasks, actions, etc)
// Call security authorization api utilizing the IoC, Singleton lifetime
//throw an exception based on the result
// Ask for specific URLs (LogOn, Register, ...)
var operationManager = new OperationManager();
var operation = operationManager.Find(areaName, controllerName, "*");
if (operation == null)
{
throw new UnauthorizedAccessException();
}
var feature = operation.Feature;
if (feature == null)
{
return;
}
var userManager = new UserManager();
var result = userManager.FindByNameAsync(username);
var featurePermissionManager = new FeaturePermissionManager();
if (!featurePermissionManager.HasAccess(result.Result?.Id, feature.Id))
{
throw new UnauthorizedAccessException();
}
}
public ActionResult GetFileLists(string menuItemPath, string contollerName)
{
//string menuItem = new DirectoryInfo(menuItemPath).Name;
bool hasDeleteRights = false;
//check user permissions for delete
using (var featurePermissionManager = new FeaturePermissionManager())
using (var featureManager = new FeatureManager())
using (UserManager userManager = new UserManager())
{
var userTask = userManager.FindByNameAsync(GetUsernameOrDefault());
userTask.Wait();
var user = userTask.Result;
List <Feature> features = featureManager.FeatureRepository.Get().ToList();
Feature feature = features.FirstOrDefault(f => f.Name.Equals(contollerName + "Admin"));
if (feature != null)
{
if (featurePermissionManager.HasAccess(user.Id, feature.Id))
{
hasDeleteRights = true;
}
}
var fileModelList = FileModel.GetFileModelList(menuItemPath, hasDeleteRights);
fileModelList.ForEach(a => a.controllerName = contollerName);
return(PartialView("~/Areas/FMT/Views/Shared/_fileList.cshtml", fileModelList));
}
}
public void GenerateSeedData()
{
FeatureManager featureManager = new FeatureManager();
OperationManager operationManager = new OperationManager();
try
{
#region SECURITY
//Features
List <Feature> features = featureManager.FeatureRepository.Get().ToList();
Feature OAIPMH = features.FirstOrDefault(f => f.Name.Equals("OAI-PMH"));
if (OAIPMH == null)
{
OAIPMH = featureManager.Create("OAI-PMH", "Open Archives Initiative Protocol for Metadata Harvesting ");
}
Feature AdminFeature = features.FirstOrDefault(f =>
f.Name.Equals("Admin") &&
f.Parent != null &&
f.Parent.Id.Equals(OAIPMH.Id));
if (AdminFeature == null)
{
AdminFeature = featureManager.Create("Admin", "Settings and customization of the protocol", OAIPMH);
}
Feature ApiFeature = features.FirstOrDefault(f =>
f.Name.Equals("API") &&
f.Parent != null &&
f.Parent.Id.Equals(OAIPMH.Id));
if (ApiFeature == null)
{
ApiFeature = featureManager.Create("Api", "Api of the OAI PMH", OAIPMH);
}
//Operations
operationManager.Create("OAIPMH", "Admin", "*", OAIPMH);
operationManager.Create("OAIPMH", "Home", "*", OAIPMH);
operationManager.Create("API", "oai", "*", OAIPMH);
var featurePermissionManager = new FeaturePermissionManager();
if (!featurePermissionManager.Exists(null, ApiFeature.Id, PermissionType.Grant))
{
featurePermissionManager.Create(null, ApiFeature.Id, PermissionType.Grant);
}
#endregion SECURITY
}
finally
{
featureManager.Dispose();
operationManager.Dispose();
}
}
private static bool hasOperationRigths(XElement operation, string userName)
{
//get parameters for the function to check
string name = userName;
string area = operation.Attribute("area").Value.ToLower();
string controller = operation.Attribute("controller").Value.ToLower();
string identifier = name + "_" + area + "_" + controller;
// check if rights already stored in the session
if (System.Web.HttpContext.Current.Session["menu_permission"] != null && ((Dictionary <string, bool>)System.Web.HttpContext.Current.Session["menu_permission"]).ContainsKey(identifier))
{
return((bool)((Dictionary <string, bool>)System.Web.HttpContext.Current.Session["menu_permission"])[identifier]);
}
FeaturePermissionManager featurePermissionManager = new FeaturePermissionManager();
OperationManager operationManager = new OperationManager();
try
{
//currently the action are not check, so we use a wildcard
string action = "*";//operation.Attribute("action").Value.ToLower();
//// check if the operation is public
//var op = operationManager.Operations.Where(x => x.Module.ToUpperInvariant() == area.ToUpperInvariant() && x.Controller.ToUpperInvariant() == controller.ToUpperInvariant() && x.Action.ToUpperInvariant() == action.ToUpperInvariant()).FirstOrDefault();
//var feature = op?.Feature;
//if (feature == null) return true;
////or user has rights
//if (string.IsNullOrEmpty(userName)) return false;
bool permission = featurePermissionManager.HasAccess <User>(name, area, controller, action);
System.Web.HttpContext.Current.Session[identifier] = permission;
// check if dictionary for menu permissions exists and create it if not
if (System.Web.HttpContext.Current.Session["menu_permission"] == null)
{
System.Web.HttpContext.Current.Session["menu_permission"] = new Dictionary <string, bool>();
}
((Dictionary <string, bool>)System.Web.HttpContext.Current.Session["menu_permission"]).Add(identifier, permission); // add menu right for the currently logged in user to session
return(permission);
}
catch (Exception ex)
{
throw ex;
}
finally
{
featurePermissionManager.Dispose();
operationManager.Dispose();
}
}
public ActionResult Show(string viewName, string rootMenu, string viewTitle)
{
ViewBag.Title = PresentationModel.GetViewTitleForTenant(viewTitle, this.Session.GetTenant());
bool hasAdminRights = false;
using (UserManager userManager = new UserManager())
using (FeaturePermissionManager featurePermissionManager = new FeaturePermissionManager())
using (FeatureManager featureManager = new FeatureManager())
{
var user = userManager.FindByNameAsync(HttpContext.User.Identity.Name).Result;
var feature = featureManager.FindByName(viewName + "Admin");
hasAdminRights = featurePermissionManager.HasAccess(user.Id, feature.Id);
}
if (String.IsNullOrEmpty(rootMenu))
{
ModelState.AddModelError("Error", "Please enter a menu root to the url!");
}
if (String.IsNullOrEmpty(viewName))
{
ModelState.AddModelError("Error", "Please enter a view name to the url!");
}
MenuHelper menuHelper = new MenuHelper();
string userName = HttpContext.User.Identity.Name;
List <FMTMenuItem> menus = null;
bool hasUserRights = false;
if (userName != "" && rootMenu != "")
{
hasUserRights = menuHelper.HasUserAccessRights(rootMenu, userName);
}
if (!hasUserRights)
{
ModelState.AddModelError("Error", "No access rights for this menu and this page!");
}
else
{
menus = menuHelper.GetMenu(rootMenu, userName);
}
//if (string.IsNullOrEmpty(rootMenu))
ViewBag.UseLayout = true;
ViewData["AdminRights"] = hasAdminRights;
return(View(viewName, menus));
}
/// <summary>
///
/// </summary>
/// <param name="subjectId"></param>
/// <param name="featureId"></param>
/// <param name="permissionType"></param>
public void DeleteFeaturePermission(long subjectId, long featureId)
{
var featurePermissionManager = new FeaturePermissionManager();
try
{
featurePermissionManager.Delete(subjectId, featureId);
}
finally
{
featurePermissionManager.Dispose();
}
}
public static void LoadSafetySettings(int presetNum)
{
if (!AreWeUsingCustomSafetySettings())
{
return;
}
Classes.SettingsPreset toLoadPreset;
try
{
toLoadPreset = Settings.availablePresets.ActualPresets[GetActualPresetFromPresetNum(presetNum)];
}
catch
{
MelonLogger.Msg("No saved safety settings could be loaded.");
return;
}
if (!IsPresetValid(toLoadPreset.settingsPresetNum))
{
MelonLogger.Msg("This preset is an empty default. Nothing to load here.");
return;
}
try
{
FeaturePermissionManager fManager = GameObject.Find("_Application").GetComponent <FeaturePermissionManager>();
foreach (Il2CppSystem.Collections.Generic.KeyValuePair <UserSocialClass, FeaturePermissionSet> rankPerm in fManager.field_Private_Dictionary_2_UserSocialClass_FeaturePermissionSet_0)
{
FeaturePermissionSet test = rankPerm.Value;
foreach (var rSetting in toLoadPreset.settingRanks.Where(rSetting => rSetting.UserRank == rankPerm.Key))
{
test.field_Public_Boolean_0 = rSetting.UserSettings["SpeakingPermission"]; // Voice
test.field_Public_Boolean_1 = rSetting.UserSettings["AvatarPermission"]; // Avatar
test.field_Public_Boolean_2 = rSetting.UserSettings["UserIconPermission"]; // UserIcons
test.field_Public_Boolean_3 = rSetting.UserSettings["AudioPermission"]; // Audio
test.field_Public_Boolean_4 = rSetting.UserSettings["ParticlesLightsPermission"]; // Light&Particles
test.field_Public_Boolean_5 = rSetting.UserSettings["ShaderPermission"]; // Shaders
test.field_Public_Boolean_6 = rSetting.UserSettings["AnimationPermission"]; // CustomAnimations
}
}
MelonLogger.Msg($"Loaded safety preset -> \"{toLoadPreset.settingsPresetName}\" ({toLoadPreset.settingsPresetNum})");
applySafety.Invoke(FeaturePermissionManager.prop_FeaturePermissionManager_0, new object[] { });
}
catch (Exception e)
{
MelonLoader.MelonLogger.Error(e.StackTrace);
}
}
/// <summary>
///
/// </summary>
/// <param name="featureId"></param>
public void RemoveFeatureFromPublic(long featureId)
{
var featurePermissionManager = new FeaturePermissionManager();
try
{
if (featurePermissionManager.Exists(null, featureId))
{
featurePermissionManager.Delete(null, featureId);
}
}
finally
{
featurePermissionManager.Dispose();;
}
}
/// <summary>
///
/// </summary>
/// <param name="featureId"></param>
public void AddFeatureToPublic(long featureId)
{
var featurePermissionManager = new FeaturePermissionManager();
try
{
if (!featurePermissionManager.Exists(null, featureId))
{
featurePermissionManager.Create(null, featureId, PermissionType.Grant);
}
}
finally
{
featurePermissionManager.Dispose();
}
}
// check permission
protected bool checkPermission(Tuple <string, string, string> LandingPage, User user)
{
var featurePermissionManager = new FeaturePermissionManager();
var operationManager = new OperationManager();
var userManager = new UserManager();
try
{
var areaName = LandingPage.Item1;
if (areaName == "")
{
areaName = "shell";
}
var controllerName = LandingPage.Item2;
var actionName = LandingPage.Item3;
var operation = operationManager.Find(areaName, controllerName, "*");
var feature = operation.Feature;
if (feature == null)
{
return(true);
}
if (featurePermissionManager.HasAccess(user.Id, feature.Id))
{
return(true);
}
else
{
return(false);
}
}
finally
{
featurePermissionManager.Dispose();
operationManager.Dispose();
userManager.Dispose();
}
}
public ActionResult Subjects_Select(long featureId)
{
FeaturePermissionManager featurePermissionManager = null;
SubjectManager subjectManager = null;
FeatureManager featureManager = null;
try
{
featurePermissionManager = new FeaturePermissionManager();
subjectManager = new SubjectManager();
featureManager = new FeatureManager();
var feature = featureManager.FindById(featureId);
var featurePermissions = new List <FeaturePermissionGridRowModel>();
if (feature == null)
{
return(View(new GridModel <FeaturePermissionGridRowModel> {
Data = featurePermissions
}));
}
var subjects = subjectManager.Subjects.ToList();
foreach (var subject in subjects)
{
var rightType = featurePermissionManager.GetPermissionType(subject.Id, feature.Id);
var hasAccess = featurePermissionManager.HasAccess(subject.Id, feature.Id);
featurePermissions.Add(FeaturePermissionGridRowModel.Convert(subject, featureId, rightType, hasAccess));
}
return(View(new GridModel <FeaturePermissionGridRowModel> {
Data = featurePermissions
}));
}
finally
{
featureManager?.Dispose();
featurePermissionManager?.Dispose();
subjectManager?.Dispose();
}
}
public void GenerateSeedData()
{
using (FeatureManager featureManager = new FeatureManager())
using (FeaturePermissionManager featurePermissionManager = new FeaturePermissionManager())
using (OperationManager operationManager = new OperationManager())
{
List <Feature> features = featureManager.FeatureRepository.Get().ToList();
Feature Search = features.FirstOrDefault(f => f.Name.Equals("Search"));
if (Search == null)
{
Search = featureManager.Create("Search", "Search");
}
if (!operationManager.Exists("MMM", "ShowMultimediaData", "*"))
{
operationManager.Create("MMM", "ShowMultimediaData", "*", Search);
}
}
}
public static void SaveSafetySettings(int presetNum, string name)
{
try
{
FeaturePermissionManager fManager = GameObject.Find("_Application").GetComponent <FeaturePermissionManager>();
fManager.Method_Public_Void_2(); // Apply current safety settings
List <Classes.RankSetting> rankSettingList = new List <Classes.RankSetting> {
};
foreach (Il2CppSystem.Collections.Generic.KeyValuePair <UserSocialClass, FeaturePermissionSet> rankPerm in fManager.field_Private_Dictionary_2_UserSocialClass_FeaturePermissionSet_0)
{
Dictionary <string, bool> tempSettings = new Dictionary <string, bool>
{
{ "SpeakingPermission", rankPerm.Value.field_Public_Boolean_0 },
{ "AvatarPermission", rankPerm.Value.field_Public_Boolean_1 },
{ "UserIconPermission", rankPerm.Value.field_Public_Boolean_2 },
{ "AudioPermission", rankPerm.Value.field_Public_Boolean_3 },
{ "ParticlesLightsPermission", rankPerm.Value.field_Public_Boolean_4 },
{ "ShaderPermission", rankPerm.Value.field_Public_Boolean_5 },
{ "AnimationPermission", rankPerm.Value.field_Public_Boolean_6 }
};
Classes.RankSetting tempRankSetting = new Classes.RankSetting(rankPerm.Key, tempSettings);
rankSettingList.Add(tempRankSetting);
}
Classes.SettingsPreset presetTest = new Classes.SettingsPreset(presetNum, name);
presetTest.settingRanks = rankSettingList;
Settings.availablePresets.ActualPresets[presetNum - 1] = presetTest;
Helpers.SaveSafetyJSON();
MelonLoader.MelonLogger.Msg($"Saved safety preset -> \"{name}\" ({presetNum})");
Settings.UpdateSelectablePresets();
}
catch (Exception e)
{
MelonLoader.MelonLogger.Error(e.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="subjectId"></param>
/// <param name="featureId"></param>
/// <param name="permissionType"></param>
public void CreateOrUpdateFeaturePermission(long?subjectId, long featureId, int permissionType)
{
var featurePermissionManager = new FeaturePermissionManager();
try
{
var featurePermission = featurePermissionManager.Find(subjectId, featureId);
if (featurePermission != null)
{
featurePermission.PermissionType = (PermissionType)permissionType;
featurePermissionManager.Update(featurePermission);
}
else
{
featurePermissionManager.Create(subjectId, featureId, (PermissionType)permissionType);
}
}
finally
{
featurePermissionManager.Dispose();
}
}
public override void OnAuthorization(AuthorizationContext filterContext)
{
var featurePermissionManager = new FeaturePermissionManager();
var operationManager = new OperationManager();
var userManager = new UserManager();
try
{
//
// get values from request
var areaName = "Shell";
try
{
areaName = filterContext.RouteData.DataTokens["area"].ToString();
}
catch
{
// ignored
}
var controllerName = filterContext.ActionDescriptor.ControllerDescriptor.ControllerName;
var actionName = filterContext.ActionDescriptor.ActionName;
var userName = string.Empty;
if (filterContext.HttpContext.User.Identity.IsAuthenticated)
{
userName = filterContext.HttpContext.User.Identity.Name;
}
//
// check request
var operation = operationManager.Find(areaName, controllerName, "*");
if (operation == null)
{
filterContext.Result = new RedirectToRouteResult(new
RouteValueDictionary {
{ "action", "AccessDenied" },
{ "controller", "Error" },
{ "Area", string.Empty }
});
return;
}
var feature = operation.Feature;
if (feature == null)
{
return;
}
var result = userManager.FindByNameAsync(userName);
if (featurePermissionManager.HasAccess(result.Result?.Id, feature.Id))
{
return;
}
if (!filterContext.HttpContext.User.Identity.IsAuthenticated)
{
HandleUnauthorizedRequest(filterContext);
}
else
{
filterContext.Result = new RedirectToRouteResult(new
RouteValueDictionary {
{ "action", "AccessDenied" },
{ "controller", "Error" },
{ "Area", string.Empty }
});
}
}
finally
{
featurePermissionManager.Dispose();
operationManager.Dispose();
userManager.Dispose();
}
}
public ActionResult Subjects_Select(GridCommand command, long featureId)
{
FeaturePermissionManager featurePermissionManager = null;
SubjectManager subjectManager = null;
FeatureManager featureManager = null;
try
{
featurePermissionManager = new FeaturePermissionManager();
subjectManager = new SubjectManager();
featureManager = new FeatureManager();
var feature = featureManager.FindById(featureId);
var featurePermissions = new List <FeaturePermissionGridRowModel>();
if (feature == null)
{
return(View(new GridModel <FeaturePermissionGridRowModel> {
Data = featurePermissions
}));
}
var subjects = new List <Subject>();
int count = subjectManager.Subjects.Count();
ViewData["subjectsGridTotal"] = count;
if (command != null)// filter subjects based on grid filter settings
{
FilterExpression filter = TelerikGridHelper.Convert(command.FilterDescriptors.ToList());
OrderByExpression orderBy = TelerikGridHelper.Convert(command.SortDescriptors.ToList());
subjects = subjectManager.GetSubjects(filter, orderBy, command.Page, command.PageSize, out count);
}
else
{
subjects = subjectManager.Subjects.ToList();
}
//foreach (var subject in subjects)
//{
// var rightType = featurePermissionManager.GetPermissionType(subject.Id, feature.Id);
// var hasAccess = featurePermissionManager.HasAccess(subject.Id, feature.Id);
// featurePermissions.Add(FeaturePermissionGridRowModel.Convert(subject, featureId, rightType, hasAccess));
//}
var subjectIds = subjects.Select(s => s.Id);
var userPermissionDic = featurePermissionManager.GetPermissionType(subjectIds, feature.Id);
var userHasAccessDic = featurePermissionManager.HasAccess(subjects, feature.Id);
foreach (var item in userPermissionDic)
{
var subject = subjects.Where(s => s.Id.Equals(item.Key)).FirstOrDefault();
var rightType = item.Value;
var hasAccess = userHasAccessDic[item.Key];
featurePermissions.Add(FeaturePermissionGridRowModel.Convert(subject, featureId, rightType, hasAccess));
}
return(View(new GridModel <FeaturePermissionGridRowModel> {
Data = featurePermissions, Total = count
}));
}
finally
{
featureManager?.Dispose();
featurePermissionManager?.Dispose();
subjectManager?.Dispose();
}
}
public void GenerateSeedData()
{
using (FeatureManager featureManager = new FeatureManager())
using (OperationManager operationManager = new OperationManager())
using (var featurePermissionManager = new FeaturePermissionManager())
{
#region SECURITY
//workflows = größere sachen, vielen operation
//operations = einzelne actions
//1.controller -> 1.Operation
List <Feature> features = featureManager.FeatureRepository.Get().ToList();
Feature DataDiscovery = features.FirstOrDefault(f => f.Name.Equals("Data Discovery"));
if (DataDiscovery == null)
{
DataDiscovery = featureManager.Create("Data Discovery", "Data Discovery");
}
Feature SearchFeature = features.FirstOrDefault(f =>
f.Name.Equals("Search") &&
f.Parent != null &&
f.Parent.Id.Equals(DataDiscovery.Id));
if (SearchFeature == null)
{
SearchFeature = featureManager.Create("Search", "Search", DataDiscovery);
}
Feature SearchManagementFeature = features.FirstOrDefault(f =>
f.Name.Equals("Search Managment") &&
f.Parent != null &&
f.Parent.Id.Equals(DataDiscovery.Id));
if (SearchManagementFeature == null)
{
SearchManagementFeature = featureManager.Create("Search Management", "Search Management", DataDiscovery);
}
Feature Dashboard = features.FirstOrDefault(f =>
f.Name.Equals("Dashboard") &&
f.Parent != null &&
f.Parent.Id.Equals(DataDiscovery.Id));
if (Dashboard == null)
{
Dashboard = featureManager.Create("Dashboard", "Dashboard", DataDiscovery);
}
//worklfows -> create dataset ->
//WorkflowManager workflowManager = new WorkflowManager();
//var operation = new Operation();
//Workflow workflow = new Workflow();
//List<Workflow> workflows = workflowManager.WorkflowRepository.Get().ToList();
#region Help Workflow
//workflow =
// workflows.FirstOrDefault(w =>
// w.Name.Equals("Search Help") &&
// w.Feature != null &&
// w.Feature.Id.Equals(DataDiscovery.Id));
//if (workflow == null) workflow = workflowManager.Create("Search Help", "", DataDiscovery);
//operationManager.Create("DDM", "Help", "*", null, workflow);
operationManager.Create("DDM", "Help", "*");
#endregion
#region Search Workflow
// ToDo -> David, Sven
// [Sven / 2017-08-21]
// I had to remove the feature to get dashboard running without DDM feature permissions.
// We have to think about how we can fix it in a long run. Maybe "DDM/Home" is not the proper
// place for dashboard!?
operationManager.Create("DDM", "PublicSearch", "*");
operationManager.Create("DDM", "Home", "*", SearchFeature);
operationManager.Create("DDM", "Data", "*", SearchFeature);
if (!featurePermissionManager.Exists(null, SearchFeature.Id, PermissionType.Grant))
{
featurePermissionManager.Create(null, SearchFeature.Id, PermissionType.Grant);
}
#endregion
#region Search Admin Workflow
operationManager.Create("DDM", "Admin", "*", SearchManagementFeature);
#endregion
#region Dashboard
operationManager.Create("DDM", "Dashboard", "*", Dashboard);
#endregion
#endregion
}
}
public override void OnAuthorization(HttpActionContext actionContext)
{
var featurePermissionManager = new FeaturePermissionManager();
var operationManager = new OperationManager();
var userManager = new UserManager();
try
{
// Check for HTTPS
//if (actionContext.Request.RequestUri.Scheme != Uri.UriSchemeHttps)
//{
// actionContext.Response = new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden);
// return;
//}
var areaName = "Api";
var controllerName = actionContext.ActionDescriptor.ControllerDescriptor.ControllerName;
var actionName = actionContext.ActionDescriptor.ActionName;
var operation = operationManager.Find(areaName, controllerName, "*");
if (operation == null)
{
actionContext.Response = new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden);
return;
}
var feature = operation.Feature;
if (feature != null && !featurePermissionManager.Exists(null, feature.Id))
{
if (actionContext.Request.Headers.Authorization == null)
{
actionContext.Response = new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden);
return;
}
var token = actionContext.Request.Headers.Authorization?.ToString().Substring("Bearer ".Length).Trim();
// resolve the token to the corresponding user
var users = userManager.Users.Where(u => u.Token == token);
if (users == null || users.Count() != 1)
{
actionContext.Response = new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden);
actionContext.Response.Content = new StringContent("Bearer token not exist.");
return;
}
if (!featurePermissionManager.HasAccess(users.Single().Id, feature.Id))
{
actionContext.Response = new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden);
actionContext.Response.Content = new StringContent("Token is not valid.");
return;
}
}
}
finally
{
featurePermissionManager.Dispose();
operationManager.Dispose();
userManager.Dispose();
}
}
public void GenerateSeedData()
{
FeatureManager featureManager = null;
FeaturePermissionManager featurePermissionManager = new FeaturePermissionManager();
OperationManager operationManager = new OperationManager();
try
{
featureManager = new FeatureManager();
List <Feature> features = featureManager.FeatureRepository.Get().ToList();
Feature dataPlanning = features.FirstOrDefault(f => f.Name.Equals("Data Planning"));
if (dataPlanning == null)
{
dataPlanning = featureManager.Create("Data Planning", "Data Planning Management");
}
Feature datastructureFeature = features.FirstOrDefault(f =>
f.Name.Equals("Datastructure Management") &&
f.Parent != null &&
f.Parent.Id.Equals(dataPlanning.Id));
if (datastructureFeature == null)
{
datastructureFeature = featureManager.Create("Datastructure Management", "Datastructure Management", dataPlanning);
}
if (!operationManager.Exists("RPM", "DataStructureSearch", "*"))
{
operationManager.Create("RPM", "DataStructureSearch", "*", datastructureFeature);
}
if (!operationManager.Exists("RPM", "DataStructureEdit", "*"))
{
operationManager.Create("RPM", "DataStructureEdit", "*", datastructureFeature);
}
if (!operationManager.Exists("RPM", "Structures", "*"))
{
operationManager.Create("RPM", "Structures", "*", datastructureFeature);
}
if (!operationManager.Exists("RPM", "DataStructureIO", "*"))
{
operationManager.Create("RPM", "DataStructureIO", "*", datastructureFeature);
}
Feature atributeFeature = features.FirstOrDefault(f =>
f.Name.Equals("Variable Template Management") &&
f.Parent != null &&
f.Parent.Id.Equals(dataPlanning.Id));
if (atributeFeature == null)
{
atributeFeature = featureManager.Create("Variable Template Management", "Variable Template Management", dataPlanning);
}
;
if (!operationManager.Exists("RPM", "DataAttribute", "*"))
{
operationManager.Create("RPM", "DataAttribute", "*", atributeFeature);
}
Feature unitFeature = features.FirstOrDefault(f =>
f.Name.Equals("Unit Management") &&
f.Parent != null &&
f.Parent.Id.Equals(dataPlanning.Id));
if (unitFeature == null)
{
unitFeature = featureManager.Create("Unit Management", "Unit Management", dataPlanning);
}
if (!operationManager.Exists("RPM", "Unit", "*"))
{
operationManager.Create("RPM", "Unit", "*", unitFeature);
}
Feature dataTypeFeature = features.FirstOrDefault(f =>
f.Name.Equals("Data Type Management") &&
f.Parent != null &&
f.Parent.Id.Equals(dataPlanning.Id));
if (dataTypeFeature == null)
{
dataTypeFeature = featureManager.Create("Data Type Management", "Data Type Management", dataPlanning);
}
if (!operationManager.Exists("RPM", "Home", "*"))
{
operationManager.Create("RPM", "Home", "*", dataTypeFeature);
}
if (!operationManager.Exists("RPM", "Help", "*"))
{
operationManager.Create("RPM", "Help", "*");
}
Feature api = features.FirstOrDefault(f =>
f.Name.Equals("API") &&
f.Parent != null &&
f.Parent.Id.Equals(dataPlanning.Id));
if (api == null)
{
api = featureManager.Create("API", "API", dataPlanning);
}
if (!operationManager.Exists("API", "Structures", "*"))
{
operationManager.Create("API", "Structures", "*", api);
}
//set api public
featurePermissionManager.Create(null, api.Id, Security.Entities.Authorization.PermissionType.Grant);
}
finally
{
featureManager.Dispose();
featurePermissionManager.Dispose();
operationManager.Dispose();
}
//create seed data from csv files
MappingReader mappingReader = new MappingReader();
AttributeCreator attributeCreator = new AttributeCreator();
string filePath = AppConfiguration.GetModuleWorkspacePath("RPM");
// read data types from csv file
DataTable mappedDataTypes = mappingReader.readDataTypes(filePath);
// create read data types in bpp
attributeCreator.CreateDataTypes(ref mappedDataTypes);
//// read dimensions from csv file
DataTable mappedDimensions = mappingReader.readDimensions(filePath);
// create dimensions in bpp
attributeCreator.CreateDimensions(ref mappedDimensions);
//// read units from csv file
DataTable mappedUnits = mappingReader.readUnits(filePath);
// create read units in bpp
attributeCreator.CreateUnits(ref mappedUnits);
//// read attributes from csv file
DataTable mappedAttributes = mappingReader.readAttributes(filePath);
// free memory
mappedDataTypes.Clear();
mappedDimensions.Clear();
// create read attributes in bpp
attributeCreator.CreateAttributes(ref mappedAttributes);
createResearchPlan();
//createSeedDataTypes();
//createSIUnits();
//createEmlDatasetAdv();
//createABCD();
//ImportSchema("Basic ABCD", "ABCD_2.06.XSD","Dataset","BExIS.Dlm.Entities.Data.Dataset");
//ImportSchema("Basic Eml", "eml.xsd","dataset","BExIS.Dlm.Entities.Data.Dataset");
DataStructureManager dsm = null;
try
{
dsm = new DataStructureManager();
foreach (StructuredDataStructure sds in dsm.StructuredDataStructureRepo.Get())
{
DataStructureIO.convertOrder(sds);
}
}
finally
{
dsm.Dispose();
}
}
public void GenerateSeedData()
{
// Javad:
// 1) all the create operations should check for existence of the record
// 2) failure on creating any record should rollback the whole seed data generation. It is one transaction.
// 3) failues should throw an exception with enough information to pin point the root cause
// 4) only seed data related to the functions of this modules should be genereated here.
// BUG: seed data creation is not working because of the changes that were done in the entities and services.
// TODO: reimplement the seed data creation method.
//#region Security
//// Tasks
using (OperationManager operationManager = new OperationManager())
using (FeatureManager featureManager = new FeatureManager())
using (var featurePermissionManager = new FeaturePermissionManager())
{
// find root
var root = featureManager.FindRoots().FirstOrDefault();
// administration node
var administrationFeature = featureManager.FindByName("Administration") ?? featureManager.Create("Administration", "node for all administrative features", root);
// users node
var userFeature = featureManager.FindByName("Users") ?? featureManager.Create("Users", "", administrationFeature);
var userOperation = operationManager.Find("SAM", "Users", "*") ?? operationManager.Create("SAM", "Users", "*", userFeature);
// groups node
var groupFeature = featureManager.FindByName("Groups") ?? featureManager.Create("Groups", "", administrationFeature);
var groupOperation = operationManager.Find("SAM", "Groups", "*") ?? operationManager.Create("SAM", "Groups", "*", groupFeature);
// feature permissions
var featurePermissionFeature = featureManager.FindByName("Feature Permissions") ?? featureManager.Create("Feature Permissions", "", administrationFeature);
var featurePermissionOperation = operationManager.Find("SAM", "FeaturePermissions", "*") ?? operationManager.Create("SAM", "FeaturePermissions", "*", featurePermissionFeature);
// Entity Permissions
var entityPermissionFeature = featureManager.FindByName("Entity Permissions") ?? featureManager.Create("Entity Permissions", "", administrationFeature);
var entityPermissionOperation = operationManager.Find("SAM", "EntityPermissions", "*") ?? operationManager.Create("SAM", "EntityPermissions", "*", entityPermissionFeature);
// User Permissions
var userPermissionFeature = featureManager.FindByName("User Permissions") ?? featureManager.Create("User Permissions", "", administrationFeature);
var userPermissionOperation = operationManager.Find("SAM", "UserPermissions", "*") ?? operationManager.Create("SAM", "UserPermissions", "*", userPermissionFeature);
// Dataset Management
var datasetManagementFeature = featureManager.FindByName("Dataset Management") ?? featureManager.Create("Dataset Management", "", administrationFeature);
var datasetManagementOperation = operationManager.Find("SAM", "Datasets", "*") ?? operationManager.Create("SAM", "Datasets", "*", datasetManagementFeature);
// Document Management
var documentManagementFeature = featureManager.FindByName("Document Management") ?? featureManager.Create("Document Management", "", administrationFeature);
var documentManagementOperation = operationManager.Find("SAM", "Files", "*") ?? operationManager.Create("SAM", "Files", "*", documentManagementFeature);
// Request
var requestManagementFeature = featureManager.FindByName("Request Management") ?? featureManager.Create("Request Management", "", administrationFeature);
var requestManagementOperation = operationManager.Find("SAM", "RequestsAdmin", "*") ?? operationManager.Create("SAM", "RequestsAdmin", "*", requestManagementFeature);
var requestOperation = operationManager.Find("SAM", "Requests", "*") ?? operationManager.Create("SAM", "Requests", "*");
// Help
var helpOperation = operationManager.Find("SAM", "Help", "*") ?? operationManager.Create("SAM", "Help", "*");
if (!featurePermissionManager.Exists(null, featurePermissionFeature.Id, PermissionType.Grant))
{
featurePermissionManager.Create(null, featurePermissionFeature.Id, PermissionType.Grant);
}
}
}
