public void AddInstanceToPublic(long entityId, long instanceId) { var entityPermissionManager = new EntityPermissionManager(); try { var entityPermission = entityPermissionManager.Find(null, entityId, instanceId); if (entityPermission == null) { entityPermissionManager.Create(null, entityId, instanceId, (int)RightType.Read); if (this.IsAccessible("DDM", "SearchIndex", "ReIndexSingle")) { var x = this.Run("DDM", "SearchIndex", "ReIndexSingle", new RouteValueDictionary() { { "id", instanceId } }); } } } finally { entityPermissionManager.Dispose(); } }
public ActionResult DeleteResourceStructureAttribute(long id) { using (var rsaManager = new ResourceStructureAttributeManager()) using (var permissionManager = new EntityPermissionManager()) using (var entityTypeManager = new EntityManager()) { ResourceStructureAttribute rsa = rsaManager.GetResourceStructureAttributesById(id); if (rsa != null) { bool deleted = rsaManager.DeleteResourceStructureAttribute(rsa); if (deleted) { Type entityType = entityTypeManager.FindByName("Notification").EntityType; //delete security permissionManager.Delete(entityType, id); } } else { //rsa not exsits, need implemention here } } return(View("ResourceStructureAttributeManager")); }
public ActionResult Activity() { ViewBag.Title = PresentationModel.GetViewTitleForTenant("Manage Activities", Session.GetTenant()); List <ActivityModel> model = new List <ActivityModel>(); using (var rManager = new ActivityManager()) using (var permissionManager = new EntityPermissionManager()) using (var entityTypeManager = new EntityManager()) { List <Activity> data = rManager.GetAllActivities().ToList(); // get id from loged in user long userId = UserHelper.GetUserId(HttpContext.User.Identity.Name); // get entity type id long entityTypeId = entityTypeManager.FindByName("Activity").Id; foreach (Activity a in data) { ActivityModel temp = new ActivityModel(a); // temp.InUse = rManager.IsInEvent(a.Id); // get permission from logged in user temp.EditAccess = permissionManager.HasEffectiveRight(userId, new List <long> { entityTypeId }, a.Id, RightType.Read); temp.DeleteAccess = permissionManager.HasEffectiveRight(userId, new List <long> { entityTypeId }, a.Id, RightType.Delete); model.Add(temp); } } return(View("ActivityManager", model)); }
public override void OnActionExecuting(ActionExecutingContext filterContext) { var entityPermissionManager = new EntityPermissionManager(); var userManager = new UserManager(); try { var userName = string.Empty; if (filterContext.HttpContext.User.Identity.IsAuthenticated) { userName = filterContext.HttpContext.User.Identity.Name; } if (!entityPermissionManager.HasEffectiveRight(userName, entityType, Convert.ToInt64(filterContext.ActionParameters[keyName]), rightType)) { filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary { { "action", "AccessDenied" }, { "controller", "Error" }, { "Area", string.Empty } }); } } finally { entityPermissionManager.Dispose(); userManager.Dispose(); } }
/// <summary> /// Deletes a dataset, which means the dataset is marked as deleted, but is not physically removed from the database. /// </summary> /// <param name="id">the identifier of the dataset to be purged.</param> /// <remarks>When a dataset is deleted, it is consodered as non-exisiting, but for the sake or provenance, citation, history, etc, it is not removed froom the database. /// The function to recover a deleted dataset, will not be provided.</remarks> /// <returns></returns> public ActionResult Delete(long id) { var datasetManager = new DatasetManager(); var entityPermissionManager = new EntityPermissionManager(); try { if (datasetManager.DeleteDataset(id, ControllerContext.HttpContext.User.Identity.Name, true)) { //entityPermissionManager.Delete(typeof(Dataset), id); // This is not needed here. if (this.IsAccessibale("DDM", "SearchIndex", "ReIndexUpdateSingle")) { var x = this.Run("DDM", "SearchIndex", "ReIndexUpdateSingle", new RouteValueDictionary() { { "id", id }, { "actionType", "DELETE" } }); } } } catch (Exception e) { ViewData.ModelState.AddModelError("", $@"Dataset {id} could not be deleted."); } return(View()); //return RedirectToAction("List"); }
public void RemoveInstanceFromPublic(long entityId, long instanceId) { var entityPermissionManager = new EntityPermissionManager(); try { var entityPermission = entityPermissionManager.Find(null, entityId, instanceId); if (entityPermission == null) { return; } entityPermissionManager.Delete(entityPermission); if (this.IsAccessible("DDM", "SearchIndex", "ReIndexSingle")) { var x = this.Run("DDM", "SearchIndex", "ReIndexSingle", new RouteValueDictionary() { { "id", instanceId } }); } } finally { entityPermissionManager.Dispose(); } }
public void RemoveRightFromEntityPermission(long subjectId, long entityId, long instanceId, int rightType) { var entityPermissionManager = new EntityPermissionManager(); try { var entityPermission = entityPermissionManager.Find(subjectId, entityId, instanceId); if (entityPermission == null) { return; } if (entityPermission.Rights == rightType) { entityPermissionManager.Delete(entityPermission); } else { if ((entityPermission.Rights & rightType) == 0) { return; } entityPermission.Rights -= rightType; entityPermissionManager.Update(entityPermission); } } finally { entityPermissionManager.Dispose(); } }
/// <summary> /// Purges a dataset, which means the dataset and all its versions will be physically removed from the database. /// </summary> /// <param name="id">the identifier of the dataset to be purged.</param> /// <remarks>This operation is not revocerable.</remarks> /// <returns></returns> public ActionResult Purge(long id) { ViewBag.Title = PresentationModel.GetViewTitleForTenant("Purge", Session.GetTenant()); DatasetManager dm = new DatasetManager(); var entityPermissionManager = new EntityPermissionManager(); try { if (dm.PurgeDataset(id)) { entityPermissionManager.Delete(typeof(Dataset), id); if (this.IsAccessibale("DDM", "SearchIndex", "ReIndexUpdateSingle")) { var x = this.Run("DDM", "SearchIndex", "ReIndexUpdateSingle", new RouteValueDictionary() { { "id", id }, { "actionType", "DELETE" } }); } } } catch (Exception e) { ViewData.ModelState.AddModelError("", string.Format("Dataset {0} could not be purged.", id)); } return(View()); }
public ActionResult Subjects_Select(long entityId, long instanceId) { var subjectManager = new SubjectManager(); var entityPermissionManager = new EntityPermissionManager(); try { var subjects = new List <EntityPermissionGridRowModel>(); foreach (var subject in subjectManager.Subjects) { var rights = entityPermissionManager.GetRights(subject.Id, entityId, instanceId); var effectiveRights = entityPermissionManager.GetEffectiveRights(subject.Id, entityId, instanceId); subjects.Add(EntityPermissionGridRowModel.Convert(subject, rights, effectiveRights)); } return(View(new GridModel <EntityPermissionGridRowModel> { Data = subjects })); } finally { subjectManager.Dispose(); entityPermissionManager.Dispose(); } }
public void AddRightToEntityPermission(long subjectId, long entityId, long instanceId, int rightType) { var entityPermissionManager = new EntityPermissionManager(); try { var entityPermission = entityPermissionManager.Find(subjectId, entityId, instanceId); if (entityPermission == null) { entityPermissionManager.Create(subjectId, entityId, instanceId, rightType); } else { if ((entityPermission.Rights & rightType) != 0) { return; } entityPermission.Rights += rightType; entityPermissionManager.Update(entityPermission); } } finally { entityPermissionManager.Dispose(); } }
// GET: ShowMultimediaData public ActionResult Index(long datasetID, string entityType = "Dataset") { ViewData["id"] = datasetID; EntityPermissionManager entityPermissionManager = null; try { entityPermissionManager = new EntityPermissionManager(); ViewData["edit"] = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), datasetID, RightType.Write); bool access = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), datasetID, RightType.Read); if (access) { return(View(getFilesByDatasetId(datasetID, entityType))); } else { return(null); } } catch { return(null); } finally { entityPermissionManager.Dispose(); } }
/// <summary> /// Shows a berif intro about the functions available as well as some warnings that inofrom the user about non recoverability of some of the operations /// such as purge. /// </summary> /// <returns></returns> public ActionResult Index() { ViewBag.Title = PresentationModel.GetViewTitleForTenant("Maintain Datasets", Session.GetTenant()); using (DatasetManager dm = new DatasetManager()) using (var entityPermissionManager = new EntityPermissionManager()) { List <Dataset> datasets = new List <Dataset>(); List <long> datasetIds = new List <long>(); datasets = dm.DatasetRepo.Query().OrderBy(p => p.Id).ToList(); datasetIds = datasets.Select(p => p.Id).ToList(); // dataset id, dataset status, number of data tuples of the latest version, number of variables in the dataset's structure List <DatasetStatModel> datasetStat = new List <DatasetStatModel>(); foreach (Dataset ds in datasets) { long noColumns = ds.DataStructure.Self is StructuredDataStructure ? (ds.DataStructure.Self as StructuredDataStructure).Variables.Count() : 0L; long noRows = 0; //ds.DataStructure.Self is StructuredDataStructure ? dm.GetDatasetLatestVersionEffectiveTupleCount(ds) : 0; // It would save time to calc the row count for all the datasets at once! bool synced = false; if (string.Compare(ds.StateInfo?.State, "Synced", true) == 0 && ds.StateInfo?.Timestamp != null && ds.StateInfo?.Timestamp > DateTime.MinValue && ds.StateInfo?.Timestamp < DateTime.MaxValue) { synced = ds.StateInfo?.Timestamp >= ds.LastCheckIOTimestamp; } datasetStat.Add(new DatasetStatModel { Id = ds.Id, Status = ds.Status, NoOfRows = noRows, NoOfCols = noColumns, IsSynced = synced }); } ViewData["DatasetIds"] = datasetIds; return(View(datasetStat)); } }
public List <FileInformation> getFilesByDatasetId(long datasetId, string entityType, long versionNo = 0) { EntityPermissionManager entityPermissionManager = null; DatasetManager datasetManager = null; try { entityPermissionManager = new EntityPermissionManager(); datasetManager = new DatasetManager(); bool access = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), datasetId, RightType.Read); if (access) { Session["EntityType"] = entityType; return(getFilesByDataset(datasetManager.DatasetRepo.Get(datasetId), datasetManager, entityType, versionNo)); } else { return(null); } } catch { return(null); } finally { entityPermissionManager.Dispose(); datasetManager.Dispose(); } }
public BexisIndexer() { entityPermissionManager = new EntityPermissionManager(); entityManager = new EntityManager(); entityTypeId = entityManager.FindByName(typeof(Dataset).Name)?.Id; entityTypeId = entityTypeId.HasValue ? entityTypeId.Value : -1; }
private bool hasUserRights(long entityId, RightType rightType) { #region security permissions and authorisations check EntityPermissionManager entityPermissionManager = new EntityPermissionManager(); return(entityPermissionManager.HasEffectiveRight(GetUsernameOrDefault(), "Dataset", typeof(Dataset), entityId, rightType)); #endregion security permissions and authorisations check }
public ActionResult Subjects_Select(GridCommand command, long entityId, long instanceId) { var subjectManager = new SubjectManager(); var entityPermissionManager = new EntityPermissionManager(); try { var subjectsDb = new List <Subject>(); var count = 0; if (command != null)// filter subjects based on grid filter settings { FilterExpression filter = TelerikGridHelper.Convert(command.FilterDescriptors.ToList()); OrderByExpression orderBy = TelerikGridHelper.Convert(command.SortDescriptors.ToList()); subjectsDb = subjectManager.GetSubjects(filter, orderBy, command.Page, command.PageSize, out count); } else { subjectsDb = subjectManager.Subjects.ToList(); count = subjectsDb.Count(); } var subjects = new List <EntityPermissionGridRowModel>(); //using (PartyManager partyManager = new PartyManager()) //foreach (var subject in subjectsDb) //{ // var rights = entityPermissionManager.GetRights(subject.Id, entityId, instanceId); // var effectiveRights = entityPermissionManager.GetEffectiveRights(subject.Id, entityId, instanceId); // subjects.Add(EntityPermissionGridRowModel.Convert(subject, rights, effectiveRights)); //} var rightsDic = entityPermissionManager.GetRights(subjectsDb, entityId, instanceId); var effectiveRightsDic = entityPermissionManager.GetEffectiveRights(subjectsDb, entityId, instanceId); foreach (var item in rightsDic) { var subject = subjectsDb.Where(s => s.Id.Equals(item.Key)).FirstOrDefault(); var rights = item.Value; var effectiveRights = effectiveRightsDic[item.Key]; subjects.Add(EntityPermissionGridRowModel.Convert(subject, rights, effectiveRights)); } return(View(new GridModel <EntityPermissionGridRowModel> { Data = subjects, Total = count })); } finally { subjectManager.Dispose(); entityPermissionManager.Dispose(); } }
public void CreateAsync_GroupIsNull_ReturnZero(short rights, string[] result) { //Arrange var a = new EntityPermissionManager(); //Act var r = a.GetRights(rights); //Assert Assert.That(result, Is.EquivalentTo(r)); }
public ActionResult Permissions_Select(long subjectId, long entityId, long instanceId) { using (var entityPermissionManager = new EntityPermissionManager()) using (var subjectManager = new SubjectManager()) using (var partyManager = new PartyManager()) using (var entityManager = new EntityManager()) { var subject = subjectManager.SubjectRepository.Get(subjectId); var entityPermissions = new List <ReferredEntityPermissionGridRowModel>(); // User & Group Permissions if (subject is User) { var user = subject as User; // Group Permissions foreach (var group in user.Groups) { entityPermissions.Add(ReferredEntityPermissionGridRowModel.Convert(group.Name, "Group", entityPermissionManager.GetRights(group.Id, entityId, instanceId))); } // Party Relationships var userParty = partyManager.GetPartyByUser(user.Id); if (userParty != null) { var entityParty = partyManager.Parties.FirstOrDefault(m => m.PartyType.Title == entityManager.FindById(entityId).Name&& m.Name == instanceId.ToString()); if (entityParty != null) { var partyRelationships = partyManager.PartyRelationships.Where(m => m.SourceParty.Id == userParty.Id && m.TargetParty.Id == entityParty.Id); foreach (var partyRelationship in partyRelationships) { entityPermissions.Add(ReferredEntityPermissionGridRowModel.Convert("Party Relationship", partyRelationship.Title, partyRelationship.Permission)); } } } } // Public Permission var publicRights = entityPermissionManager.GetRights(subjectId: null, entityId, instanceId); if (publicRights > 0) { entityPermissions.Add(ReferredEntityPermissionGridRowModel.Convert("Public Dataset", "", publicRights)); } return(View(new GridModel <ReferredEntityPermissionGridRowModel> { Data = entityPermissions })); } }
public FileResult getFile(string path) { path = Server.UrlDecode(path); if (FileHelper.FileExist(Path.Combine(AppConfiguration.DataPath, path))) { EntityPermissionManager entityPermissionManager = null; DatasetManager datasetManager = null; try { entityPermissionManager = new EntityPermissionManager(); datasetManager = new DatasetManager(); DatasetInfo datasetInfo = (DatasetInfo)Session["DatasetInfo"]; string entityType = (string)Session["EntityType"]; long datasetID = datasetInfo.DatasetId; bool access = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), datasetID, RightType.Read); if (access) { path = Path.Combine(AppConfiguration.DataPath, path); FileInfo fileInfo = new FileInfo(path); Session["DatasetInfo"] = datasetInfo; Session["EntityType"] = entityType; // after 2.14.1 files are stored in original names // by download only the files, the user need to know th edataset id and the version number int versionNr = datasetManager.GetDatasetVersionNr(datasetInfo.DatasetVersionId); string filename = datasetInfo.DatasetId + "_" + versionNr + "_" + fileInfo.Name; return(File(path, MimeMapping.GetMimeMapping(fileInfo.Name), filename)); } else { Session["DatasetInfo"] = datasetInfo; return(null); } } catch (Exception ex) { return(null); } finally { entityPermissionManager.Dispose(); datasetManager.Dispose(); } } else { WebRequest request = WebRequest.Create(path); HttpWebResponse response = (HttpWebResponse)request.GetResponse(); return(File(response.GetResponseStream(), MimeMapping.GetMimeMapping(response.ResponseUri.Segments.LastOrDefault()), response.ResponseUri.Segments.LastOrDefault())); } }
public Stream getFileStream(string path) { path = Server.UrlDecode(path); if (FileHelper.FileExist(Path.Combine(AppConfiguration.DataPath, path))) { EntityPermissionManager entityPermissionManager = null; try { entityPermissionManager = new EntityPermissionManager(); DatasetInfo datasetInfo = (DatasetInfo)Session["DatasetInfo"]; string entityType = (string)Session["EntityType"]; long datasetID = datasetInfo.DatasetId; bool access = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), datasetID, RightType.Read); if (access) { path = Path.Combine(AppConfiguration.DataPath, path); Session["DatasetInfo"] = datasetInfo; Session["EntityType"] = entityType; return(System.IO.File.OpenRead(path)); } else { Session["DatasetInfo"] = datasetInfo; Session["EntityType"] = entityType; return(null); } } catch { return(null); } finally { entityPermissionManager.Dispose(); } } else { try { WebRequest request = WebRequest.Create(path); HttpWebResponse response = (HttpWebResponse)request.GetResponse(); return(response.GetResponseStream()); } catch { return(null); } } }
public ActionResult Decisions(long entityId, string status = "") { using (var entityManager = new EntityManager()) using (var entityPermissionManager = new EntityPermissionManager()) using (var decisionManager = new DecisionManager()) { var entityStore = (IEntityStore)Activator.CreateInstance(entityManager.FindById(entityId).EntityStoreType); IQueryable <Decision> decisions = null; if (status == "Open") { ViewData["status"] = "Open"; decisions = decisionManager.Decisions.Where(d => d.Request.Entity.Id == entityId && d.Request.Status == 0); } else { decisions = decisionManager.Decisions.Where(d => d.Request.Entity.Id == entityId); } List <DecisionGridRowModel> model = new List <DecisionGridRowModel>(); foreach (var m in decisions) { //check if the entity exist otherwise set a default text for the user; string title = entityStore.Exist(m.Request.Key) ? entityStore.GetTitleById(m.Request.Key) : "Dataset currently / no longer accessible"; bool exist = entityStore.Exist(m.Request.Key); model.Add( new DecisionGridRowModel() { Id = m.Id, RequestId = m.Request.Id, Rights = string.Join(", ", entityPermissionManager.GetRights(m.Request.Rights)), //string.Join(",", Enum.GetNames(typeof(RightType)).Select(n => n).Where(n => (m.Request.Rights & (short)Enum.Parse(typeof(RightType), n)) > 0)), Status = m.Status, StatusAsText = Enum.GetName(typeof(DecisionStatus), m.Status), InstanceId = m.Request.Key, Title = title, Applicant = getPartyName(m.Request.Applicant), DecisionMaker = getPartyName(m.DecisionMaker), Intention = m.Request.Intention, RequestDate = m.Request.RequestDate, EntityExist = exist }); } ViewData["entityID"] = entityId; return(PartialView("_DecisionsAdmin", model.OrderBy(x => x.Status).ThenBy(n => n.Id))); } }
public List <long> Get() { // get token from the request string token = this.Request.Headers.Authorization?.Parameter; // flag for the public dataset check bool isPublic = false; List <long> ids = new List <long>(); using (var datasetManager = new DatasetManager()) { var datasetIds = datasetManager.GetDatasetLatestIds(); foreach (var id in datasetIds) { using (EntityPermissionManager entityPermissionManager = new EntityPermissionManager()) using (EntityManager entityManager = new EntityManager()) using (UserManager userManager = new UserManager()) { // load the entity id of the e.g. is it a sample or dataset or publication long?entityTypeId = entityManager.FindByName(typeof(Dataset).Name)?.Id; entityTypeId = entityTypeId.HasValue ? entityTypeId.Value : -1; // if the subject is null and one entry exist, means this dataset is public isPublic = entityPermissionManager.Exists(null, entityTypeId.Value, id); // load user based on token User user = userManager.Users.Where(u => u.Token.Equals(token)).FirstOrDefault(); if (isPublic || user != null) { if (isPublic || entityPermissionManager.HasEffectiveRight(user.Name, typeof(Dataset), id, RightType.Read)) { var filepath = Path.Combine(AppConfiguration.DataPath, "Datasets", id.ToString(), "geoengine.json"); if (File.Exists(filepath)) { ids.Add(id); } } } } } } return(ids); }
public JsonResult Submit(bool valid) { // create and submit Dataset using (var createDatasetController = new CreateDatasetController()) { try { // how to hold the seesion: https://stackoverflow.com/questions/31388357/session-is-null-when-calling-method-from-one-controller-to-another-mvc createDatasetController.ControllerContext = new ControllerContext(this.Request.RequestContext, createDatasetController); long datasetId = createDatasetController.SubmitDataset(valid, "Publication"); //get groups from setting file var adminGroup = Helper.Settings.get("adminGroup").ToString(); var pubAdminGroup = Helper.Settings.get("pubAdminGroup").ToString(); var pubInternGroup = Helper.Settings.get("pubInternGroup").ToString(); using (EntityPermissionManager entityPermissionManager = new EntityPermissionManager()) { if (!String.IsNullOrEmpty(adminGroup)) { entityPermissionManager.Create <Group>("administrator", "Publication", typeof(Dataset), datasetId, Enum.GetValues(typeof(RightType)).Cast <RightType>().ToList()); } if (!String.IsNullOrEmpty(pubAdminGroup)) { entityPermissionManager.Create <Group>("publicationAdmin", "Publication", typeof(Dataset), datasetId, new List <RightType>() { RightType.Read, RightType.Write, RightType.Delete }); } if (!String.IsNullOrEmpty(pubInternGroup)) { entityPermissionManager.Create <Group>("1_publicationIntern", "Publication", typeof(Dataset), datasetId, new List <RightType>() { RightType.Read }); } } return(Json(new { result = "redirect", url = Url.Action("Index", "UploadPublication", new { area = "Pub", entityId = datasetId }) }, JsonRequestBehavior.AllowGet)); } catch (Exception ex) { return(Json(new { result = "error", message = ex.Message }, JsonRequestBehavior.AllowGet)); } } }
public DataApiHelper(Dataset dataset, User user, DataApiModel data, string title, UploadMethod uploadMethod) { datasetManager = new DatasetManager(); userManager = new UserManager(); entityPermissionManager = new EntityPermissionManager(); dataStructureManager = new DataStructureManager(); uploadHelper = new UploadHelper(); _dataset = dataset; _user = user; _data = data; _title = title; _uploadMethod = uploadMethod; _dataStructure = dataStructureManager.StructuredDataStructureRepo.Get(_dataset.DataStructure.Id); reader = new AsciiReader(_dataStructure, new AsciiFileReaderInfo()); }
public FileResult getFileStreamResult(string path) { path = Server.UrlDecode(path); if (FileHelper.FileExist(Path.Combine(AppConfiguration.DataPath, path))) { EntityPermissionManager entityPermissionManager = null; try { entityPermissionManager = new EntityPermissionManager(); DatasetInfo datasetInfo = (DatasetInfo)Session["DatasetInfo"]; string entityType = (string)Session["EntityType"]; long datasetID = datasetInfo.DatasetId; bool access = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), datasetID, RightType.Read); if (access) { path = Path.Combine(AppConfiguration.DataPath, path); FileInfo fileInfo = new FileInfo(path); Session["DatasetInfo"] = datasetInfo; Session["EntityType"] = entityType; return(new FileStreamResult(new FileStream(path, FileMode.Open), MimeMapping.GetMimeMapping(fileInfo.Name))); } else { Session["DatasetInfo"] = datasetInfo; Session["EntityType"] = entityType; return(null); } } catch { return(null); } finally { entityPermissionManager.Dispose(); } } else { WebRequest request = WebRequest.Create(path); HttpWebResponse response = (HttpWebResponse)request.GetResponse(); return(new FileStreamResult(response.GetResponseStream(), MimeMapping.GetMimeMapping(response.ResponseUri.Segments.LastOrDefault()))); } }
public void AddInstanceToPublic(long entityId, long instanceId) { var entityPermissionManager = new EntityPermissionManager(); try { var entityPermission = entityPermissionManager.Find(null, entityId, instanceId); if (entityPermission == null) { entityPermissionManager.Create(null, entityId, instanceId, (int)RightType.Read); } } finally { entityPermissionManager.Dispose(); } }
public List <FileInformation> getFilesByDataset(Dataset dataset, DatasetManager datasetManager, string entityType, long versionId = 0) { EntityPermissionManager entityPermissionManager = null; try { List <FileInformation> fileInfos = new List <FileInformation>(); entityPermissionManager = new EntityPermissionManager(); bool access = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), dataset.Id, RightType.Read); if (dataset != null && access) { DatasetVersion datasetVersion = new DatasetVersion(); if (versionId > 0) { datasetVersion = datasetManager.GetDatasetVersion(versionId); } else { datasetVersion = datasetManager.GetDatasetLatestVersion(dataset); } if (datasetVersion != null) { List <ContentDescriptor> contentDescriptors = datasetVersion.ContentDescriptors.ToList(); if (contentDescriptors.Count > 0) { foreach (ContentDescriptor cd in contentDescriptors) { if (cd.Name.ToLower().Equals("unstructureddata")) { fileInfos.Add(getFileInfo(cd)); } } } } } return(fileInfos); } finally { entityPermissionManager.Dispose(); } }
private static List <MappingEntityResultElement> getAllValuesFromEntites(IEnumerable <Entities.Mapping.Mapping> mappings, string value) { List <MappingEntityResultElement> tmp = new List <MappingEntityResultElement>(); EntityManager entityManager = new EntityManager(); EntityPermissionManager entityPermissionManager = new EntityPermissionManager(); try { foreach (var mapping in mappings) { //load the entiy for each source element id wich is the entity id var entity = entityManager.EntityRepository.Get(mapping.Source.ElementId); // load all existing entity objects iwith the defined manager var instanceStore = (IEntityStore)Activator.CreateInstance(entityManager.FindById(entity.Id).EntityStoreType); var instances = instanceStore.GetEntities().Where(e => e.Title.ToLower().Contains(value.ToLower())).Select(i => new MappingEntityResultElement() { EntityId = i.Id, EntityTypeId = entity.Id, Value = i.Title, Url = "url to " + i.Id }).ToList(); //check if allready exist in list if (instances.Any()) { foreach (var instance in instances) { if (!tmp.Any(i => i.EntityId.Equals(instance.EntityId) && i.EntityTypeId.Equals(instance.EntityTypeId))) { tmp.Add(instance); } } } } } finally { entityManager.Dispose(); entityPermissionManager.Dispose(); } return(tmp.OrderBy(i => i.Value).ToList()); }
public ActionResult Create(CreateResourceStructureModel model) { using (ResourceStructureManager rsManager = new ResourceStructureManager()) using (var pManager = new EntityPermissionManager()) using (var entityTypeManager = new EntityManager()) using (UserManager userManager = new UserManager()) { //check name ResourceStructure temp = rsManager.GetResourceStructureByName(StringHelper.CutSpaces(model.Name)); if (temp != null) { ModelState.AddModelError("NameExist", "Name already exist"); } if (ModelState.IsValid) { ResourceStructure rS = rsManager.Create(model.Name, model.Description, null, null); //Start -> add security ---------------------------------------- var userTask = userManager.FindByNameAsync(HttpContext.User.Identity.Name); userTask.Wait(); var user = userTask.Result; Entity entityType = entityTypeManager.FindByName("ResourceStructure"); //31 is the sum from all rights: Read = 1, Write = 4, Delete = 8, Grant = 16 int rights = (int)RightType.Read + (int)RightType.Write + (int)RightType.Delete + (int)RightType.Grant; pManager.Create(user, entityType, rS.Id, rights); //End -> add security ------------------------------------------ ResourceStructureModel rSmodel = new ResourceStructureModel(rS); rSmodel.FirstCreated = true; return(View("_editResourceStructure", rSmodel)); } else { return(View("_createResourceStructure", model)); } } }
// [HttpPost] public ActionResult Create(ActivityModel model) { using (ActivityManager aManager = new ActivityManager()) { // check name Activity temp = aManager.GetActivityByName(StringHelper.CutSpaces(model.Name)); if (temp != null) { ModelState.AddModelError("NameExist", "Name already exist"); } if (ModelState.IsValid) { Activity a = aManager.CreateActivity(model.Name, model.Description, model.Disable); // Start -> add security ---------------------------------------- using (EntityPermissionManager pManager = new EntityPermissionManager()) using (SubjectManager subManager = new SubjectManager()) using (var entityTypeManager = new EntityManager()) using (UserManager userManager = new UserManager()) { var userTask = userManager.FindByNameAsync(HttpContext.User.Identity.Name); userTask.Wait(); var user = userTask.Result; Entity entityType = entityTypeManager.FindByName("Activity"); // 31 is the sum from all rights: Read = 1, Write = 4, Delete = 8, Grant = 16 int rights = (int)RightType.Read + (int)RightType.Write + (int)RightType.Delete + (int)RightType.Grant; pManager.Create(user, entityType, a.Id, rights); // End -> add security ------------------------------------------ } // return View("ActivityManager"); return(Json(new { success = true })); } else { return(PartialView("_createActivity", model)); } } }