/// <summary>
        /// Returns a info object with basic authorization details for a resource by type and foreign resource id.
        /// </summary>
        /// <param name="resourceType">The resource type.</param>
        /// <param name="foreignResourceId">The resource by foreign resource id.</param>
        /// <returns>The resource authorization info dto.</returns>
        public async Task <ResourceAuthorizationInfoDTO> GetResourceAuthorizationInfoDTOAsync(string resourceType, int foreignResourceId)
        {
            var dto = await ResourceQueries.CreateGetResourceAuthorizationInfoDTOQuery(this.Context, resourceType, foreignResourceId).FirstOrDefaultAsync();

            logger.Trace("Retrieved resource authorization info dto for resource type [{0}] and foreign resource id [{1}].", resourceType, foreignResourceId);
            return(dto);
        }
        /// <summary>
        /// Get a ResourceId giving a foreignResourceId and a ResourceTypeId
        /// </summary>
        /// <param name="foreignResourceId">The foreign resource id.</param>
        /// <param name="resourceTypeId">The resource type.</param>
        /// <returns>The foreign resource cache.</returns>
        public ForeignResourceCache GetResourceByForeignResourceId(int foreignResourceId, int resourceTypeId)
        {
            var cache = GetCachedForeignResourceCache(foreignResourceId, resourceTypeId);

            if (cache != null)
            {
                return(cache);
            }
            else
            {
                var resource                = ResourceQueries.CreateGetResourceByForeignResourceIdQuery(this.Context, foreignResourceId, resourceTypeId).FirstOrDefault();
                int?parentResourceId        = null;
                int?parentForeignResourceId = null;
                int?parentResourceTypeId    = null;
                if (resource != null && resource.ParentResourceId.HasValue)
                {
                    var parentResource = CreateGetResourceByResourceIdQuery(resource.ParentResourceId.Value).FirstOrDefault();
                    Contract.Assert(parentResource != null, "The parent resource should not be null.");
                    parentResourceId        = parentResource.ResourceId;
                    parentForeignResourceId = parentResource.ForeignResourceId;
                    parentResourceTypeId    = parentResource.ResourceTypeId;
                }
                var resourceId = resource != null ? resource.ResourceId : default(int?);
                return(HandleNonCachedResource(foreignResourceId, resourceId, resourceTypeId, parentForeignResourceId, parentResourceId, parentResourceTypeId));
            }
        }
        /// <summary>
        /// Returns resource authorizations given the query operator.
        /// </summary>
        /// <param name="queryOperator">The query operator.</param>
        /// <returns>The paged filtered and sorted resource authorizations.</returns>
        public async Task <PagedQueryResults <ResourceAuthorization> > GetResourceAuthorizationsAsync(QueryableOperator <ResourceAuthorization> queryOperator)
        {
            var results = await ResourceQueries.CreateGetResourceAuthorizationsQuery(this.Context, queryOperator).ToPagedQueryResultsAsync(queryOperator.Start, queryOperator.Limit);

            logger.Trace("Retrieved resource authorizations using query operator [{0}].", queryOperator);
            return(results);
        }
        public Payload<Resource> Delete(Resource obj)
        {
            // create payload
            var payload = new Payload<Resource>();

            // todo: check security

            // validate
            var rules = new ValidationRules();
            rules.ValidateHasId(obj);

            // assign errors from validation (if applicable)
            payload.AssignValidationErrors(rules.Errors);

            // check if valid
            if (rules.IsValid)
            {
                // db delete (inactive)
                using (var queries = new ResourceQueries())
                {
                    queries.Delete(ref obj);
                }

                payload.Data = obj;
            }

            // todo: next steps in workflow

            // return payload
            return payload;
        }
Example #5
0
    public override Dictionary <string, Sprite> GetImageOptions(int minTier)
    {
        Dictionary <string, Sprite> nameSpriteDict = new Dictionary <string, Sprite>();

        // Get the resourceDefs with this type
        IEnumerable <ResourceDef> resourcesOfName = ResourceQueries.ByName(ManagerBase.resourceDefinitions, name);

        foreach (ResourceDef def in resourcesOfName)
        {
            nameSpriteDict.Add(def.name, def.image);
        }

        return(nameSpriteDict);
    }
        /// <summary>
        /// Returns the permissions that can be set on a resource of the given type and resource id.  If only the
        /// permissions for the resource type are needed, null can be passed for resource id.  In this case, permission
        /// that have the same resource type but do have a resource id relationship will not be included.
        /// </summary>
        /// <param name="resourceType">The resource type.</param>
        /// <param name="foreignResourceId">The foreign resource id.</param>
        /// <returns>The available permissions for the given resource type and resource id.</returns>
        public async Task <List <ResourcePermissionDTO> > GetResourcePermissionsAsync(string resourceType, int?foreignResourceId)
        {
            throwIfResourceTypeIsNotKnown(resourceType);
            int?resourceId = null;

            if (foreignResourceId.HasValue)
            {
                resourceId = (await GetResourceByForeignResourceIdAsync(foreignResourceId.Value, ResourceType.GetStaticLookup(resourceType).Id)).ResourceId;
                logger.Trace("Retrieved resourceId [{0}] for foreign resource id [{1}].", resourceId, foreignResourceId);
            }
            var permissions = await ResourceQueries.CreateGetResourcePermissionsQuery(this.Context, resourceType, resourceId).ToListAsync();

            logger.Trace("Retrieved resource permissions for resource type [{0}] and resource id [{1}].", resourceType, resourceId);
            return(permissions);
        }
        /// <summary>
        /// Handles a single added permissable entity by adding it as a cam resource.
        /// </summary>
        /// <param name="addedEntity">The added entity.</param>
        public async Task <AddedPermissableEntityResult> OnAddedAsync(IPermissable addedEntity)
        {
            Contract.Requires(addedEntity != null, "The added entity must not be null.");
            if (addedEntity.IsExempt())
            {
                logger.Info("Permissable entity with id [{0]} and permissable type [{1}] was exempt from cam.", addedEntity.GetId(), addedEntity.GetPermissableType());
                return(null);
            }
            else
            {
                var resourceTypeName = ResourceType.GetStaticLookup(addedEntity.GetPermissableType().GetResourceTypeId());
                Contract.Assert(resourceTypeName != null, "The resource type should be recognized.");
                var resourceTypePermissions = await GetResourcePermissionsAsync(resourceTypeName.Value, null);

                var roles = await CreateGetAllRolesQuery().ToListAsync();

                var existingResource = await ResourceQueries.CreateGetResourceByForeignResourceIdQuery(this.Context, addedEntity.GetId(), addedEntity.GetPermissableType().GetResourceTypeId())
                                       .FirstOrDefaultAsync();

                Resource parentResource = null;
                if (addedEntity.GetParentId().HasValue)
                {
                    parentResource = await ResourceQueries.CreateGetResourceByForeignResourceIdQuery(
                        this.Context,
                        addedEntity.GetParentId().Value,
                        addedEntity.GetParentPermissableType().GetResourceTypeId())
                                     .FirstOrDefaultAsync();
                }

                var addedPermissableEntityResult = DoOnAdded(addedEntity: addedEntity,
                                                             existingResource: existingResource,
                                                             parentResource: parentResource,
                                                             resourceTypePermissions: resourceTypePermissions,
                                                             roles: roles);
                logger.Info("Saving cam model context changes.");
                await this.Context.SaveChangesAsync();

                return(addedPermissableEntityResult);
            }
        }
 /// <summary>
 /// Updates the given permissable entity in CAM by updating it's parent resource if necessary.
 /// </summary>
 /// <param name="updatedEntity">The updated entity.</param>
 /// <returns>The task.</returns>
 public void OnUpdated(IPermissable updatedEntity)
 {
     if (updatedEntity.IsExempt())
     {
         logger.Info("Permissable entity with id [{0]} and permissable type [{1}] was exempt from cam.", updatedEntity.GetId(), updatedEntity.GetPermissableType());
     }
     else
     {
         var      resource               = ResourceQueries.CreateGetResourceByForeignResourceIdQuery(this.Context, updatedEntity.GetId(), updatedEntity.GetPermissableType().GetResourceTypeId()).FirstOrDefault();
         Resource targetParentResource   = null;
         Resource previousParentResource = null;
         if (updatedEntity.GetParentId().HasValue)
         {
             targetParentResource = ResourceQueries.CreateGetResourceByForeignResourceIdQuery(this.Context, updatedEntity.GetParentId().Value, updatedEntity.GetParentPermissableType().GetResourceTypeId()).FirstOrDefault();
         }
         if (resource != null && resource.ParentResourceId.HasValue)
         {
             previousParentResource = Context.Resources.Find(resource.ParentResourceId.Value);
         }
         DoUpdate(updatedEntity, resource, targetParentResource, previousParentResource);
         this.Context.SaveChanges();
     }
 }
        public Payload<List<Resource>> Get()
        {
            // create payload
            var payload = new Payload<List<Resource>>();

            // todo: check security

            // get from db
            using (var queries = new ResourceQueries())
            {
                payload.Data = queries.GetQuery().ToList();
            }

            // return payload
            return payload;
        }
Example #10
0
        public Payload<List<Resource>> Search(string q)
        {
            // create payload
            var payload = new Payload<List<Resource>>();

            // todo: check security

            // validate
            var rules = new ValidationRules();
            rules.ValidateIsNotEmpty(q);

            // assign errors from validation (if applicable)
            payload.AssignValidationErrors(rules.Errors);

            // check if valid
            if (rules.IsValid)
            {
                // search db
                using (var queries = new ResourceQueries())
                {
                    payload.Data = queries.Search(q);
                }
            }

            // return payload
            return payload;
        }
Example #11
0
        public Payload<Resource> Save(Resource obj)
        {
            // create payload
            var payload = new Payload<Resource>();

            // todo: check security

            // Prep obj
            bool isNewAsset = (obj.Id <= 0);
            business.SetDefaults(ref obj);

            // Check if we need to create new subject
            foreach (var association in obj.TopicAssociations)
            {
                // Get from db and see if it already exists
                var subjectLogic = new TopicAppLogic();
                if (association.Topic == null)
                {
                    // check if exists
                    var subjectIsNew = (subjectLogic.Get(association.Tag).Data == null);
                    if (subjectIsNew)
                    {
                        // create new subject
                        association.Topic = new Topic()
                        {
                            Tag = association.Tag,
                            ContributorGuid = association.ContributorGuid,
                            Contributor = association.Contributor,
                            Created = DateTime.Now
                        };
                    }
                }
            }

            // validate
            var rules = new ValidationRules();
            rules.Validate(obj);

            // assign errors from validation (if applicable)
            payload.AssignValidationErrors(rules.Errors);

            // check if valid
            if (rules.IsValid)
            {
                // if existing asset, check the properties that have changed prior to update
                var changedProperties = new StringBuilder();
                if (!isNewAsset)
                {
                    var originalAsset = Get(obj.Id).Data;
                    CheckChangedProperties(originalAsset, obj, ref changedProperties);
                }

                // save to db
                using (var queries = new ResourceQueries())
                {
                    queries.Save(ref obj);
                }

                // assign primary data
                payload.Data = obj;

                // log activity
                if (isNewAsset)
                {
                    // new asset
                    AuditUtilities.Log(obj.Contributor, ActivityEventItem.ResourceCreated,
                        string.Format(Resources.AuditEntries.ResourceCreated, obj.Contributor.Username));
                }
                else
                {
                    // updated asset
                    AuditUtilities.Log(obj.Contributor, ActivityEventItem.ResourceModified,
                        string.Format(Resources.AuditEntries.ResourceModified, obj.Contributor.Username, changedProperties));
                }
            }

            // todo: next steps in workflow

            // return payload
            return payload;
        }
Example #12
0
        public Payload<List<Resource>> GetBySubject(string hashtag)
        {
            // create payload
            var payload = new Payload<List<Resource>>();

            // todo: check security

            // get from db
            using (var queries = new ResourceQueries())
            {
                payload.Data = queries.GetBySubject(hashtag);
            }

            // return payload
            return payload;
        }
Example #13
0
        public Payload<Resource> Get(int id)
        {
            // create payload
            var payload = new Payload<Resource>();

            // todo: check security

            // get from db
            using (var queries = new ResourceQueries())
            {
                payload.Data = queries.Get(id);
            }

            // Check if null to add error
            if (payload.Data == null)
            {
                payload.Errors.Add("00002", Resources.Errors.ERR00002);
            }

            // return payload
            return payload;
        }