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));
}
}
}
