diff --git a/src/Project.Tests/DefaultControllerTests.cs b/src/Project.Tests/DefaultControllerTests.cs
index 0326f1b494dc823ef9350ba5880055a45729f951..146d7570c8925290090f524c505333113217e9ac 100644
--- a/src/Project.Tests/DefaultControllerTests.cs
+++ b/src/Project.Tests/DefaultControllerTests.cs
@@ -1,4 +1,5 @@
-using Coscine.Api.Project.Models;
+using Coscine.Api.Project.Controllers;
+using Coscine.Api.Project.Models;
 using Coscine.ApiCommons.Utils;
 using Coscine.Database.Model;
 using Microsoft.AspNetCore.Http;
@@ -24,10 +25,13 @@ namespace Coscine.Api.Project.Tests
         protected readonly List<ProjectRole> ProjectRoles = new List<ProjectRole>();
         protected readonly List<ResourceType> ResourceTypes = new List<ResourceType>();
         protected readonly List<Resource> Resources = new List<Resource>();
+        protected readonly List<ResourceDiscipline> ResourceDisciplines = new List<ResourceDiscipline>();
 
         protected Discipline Discipline { get; set; }
         protected Institute Institute { get; set; }
         protected Visibility Visibility { get; set; }
+        protected License License { get; set; }
+        protected RDSResourceType RdsResourceType { get; set; }
 
         protected int Previous;
 
@@ -56,11 +60,14 @@ namespace Coscine.Api.Project.Tests
             instituteModel.Insert(Institute);
 
             VisibilityModel visibilityModel = new VisibilityModel();
-            Visibility = new Visibility()
+            Visibility = visibilityModel.GetWhere((visibility) => visibility.DisplayName == "Public");
+
+            LicenseModel licenseModel = new LicenseModel();
+            License = new License()
             {
-                DisplayName = "TestDiscipline"
+                DisplayName = "MIT"
             };
-            visibilityModel.Insert(Visibility);
+            licenseModel.Insert(License);
 
             ProjectModel projectModel = new ProjectModel();
             Previous = projectModel.GetAll().ToArray().Length;
@@ -97,6 +104,20 @@ namespace Coscine.Api.Project.Tests
             var projectRole = projectModel.SetOwner(project, user);
             ProjectRoles.Add(projectRole);
 
+            ProjectDisciplineModel projectDisciplineModel = new ProjectDisciplineModel();
+            projectDisciplineModel.Insert(new ProjectDiscipline()
+            {
+                DisciplineId = Discipline.Id,
+                ProjectId = project.Id
+            });
+
+            ProjectInstituteModel projectInstituteModel = new ProjectInstituteModel();
+            projectInstituteModel.Insert(new ProjectInstitute()
+            {
+                InstituteId = Institute.Id,
+                ProjectId = project.Id
+            });
+
             Projects.Add(projectModel.GetById(project.Id));
 
             var project2 = new Coscine.Database.Model.Project()
@@ -117,37 +138,70 @@ namespace Coscine.Api.Project.Tests
             Projects.Add(projectModel.GetById(project2.Id));
 
             ResourceTypeModel resourceTypeModel = new ResourceTypeModel();
-            var resourceType = new ResourceType()
+            var resourceType = resourceTypeModel.GetWhere((dbResourceType) => dbResourceType.DisplayName == "rds");
+
+            RDSResourceTypeModel rdsResourceTypeModel = new RDSResourceTypeModel();
+            RdsResourceType = new RDSResourceType()
             {
-                DisplayName = "TestType"
+                AccessKey = "a",
+                SecretKey = "b",
+                BucketName = "c",
             };
-            resourceTypeModel.Insert(resourceType);
-            ResourceTypes.Add(resourceType);
+            rdsResourceTypeModel.Insert(RdsResourceType);
 
             ResourceModel resourceModel = new ResourceModel();
             var resource = new Resource()
             {
-                ExternalId = "123",
-                Url = "http://rwth-aachen.de/test",
                 DisplayName = "ResourceTest1",
+                ResourceName = "ResourceTest1",
+                Keywords = "ResourceTest1",
+                UsageRights = "ResourceTest1",
                 TypeId = resourceType.Id,
-                Type = resourceType
+                Type = resourceType,
+
+                Visibility = Visibility,
+                VisibilityId = Visibility.Id,
+                LicenseId = License.Id,
+
+                ResourceTypeOptionId = RdsResourceType.Id
             };
             resourceModel.Insert(resource);
             projectModel.AddResource(project, resource);
             Resources.Add(resource);
 
+            resourceType = resourceTypeModel.GetWhere((dbResourceType) => dbResourceType.DisplayName == "gitlab");
             var resource2 = new Resource()
             {
-                ExternalId = "12345",
-                Url = "http://rwth-aachen.de/test2",
                 DisplayName = "ResourceTest2",
+                ResourceName = "ResourceTest2",
+                Keywords = "ResourceTest2",
+                UsageRights = "ResourceTest2",
                 TypeId = resourceType.Id,
-                Type = resourceType
+                Type = resourceType,
+
+                Visibility = Visibility,
+                VisibilityId = Visibility.Id,
+                LicenseId = License.Id
             };
             resourceModel.Insert(resource2);
             projectModel.AddResource(project2, resource2);
             Resources.Add(resource2);
+
+            ResourceDisciplineModel resourceDisciplineModel = new ResourceDisciplineModel();
+            ResourceDiscipline resourceDiscipline = new ResourceDiscipline()
+            {
+                DisciplineId = Discipline.Id,
+                ResourceId = resource.Id
+            };
+            resourceDisciplineModel.Insert(resourceDiscipline);
+            ResourceDisciplines.Add(resourceDiscipline);
+            resourceDiscipline = new ResourceDiscipline()
+            {
+                DisciplineId = Discipline.Id,
+                ResourceId = resource2.Id
+            };
+            resourceDisciplineModel.Insert(resourceDiscipline);
+            ResourceDisciplines.Add(resourceDiscipline);
         }
 
 
@@ -230,20 +284,25 @@ namespace Coscine.Api.Project.Tests
             {
                 projectResourceModel.Delete(projectResource);
             }
-            ProjectModel projectModel = new ProjectModel();
+            ProjectController projectController = new ProjectController();
             foreach (var project in Projects)
             {
-                projectModel.Delete(project);
+                projectController.DeleteProject(project);
             }
             UserModel userModel = new UserModel();
             foreach (var user in Users)
             {
                 userModel.Delete(user);
             }
+            ResourceDisciplineModel resourceDisciplineModel = new ResourceDisciplineModel();
+            foreach (var resourceDiscipline in ResourceDisciplines)
+            {
+                resourceDisciplineModel.Delete(resourceDiscipline);
+            }
             ResourceModel resourceModel = new ResourceModel();
             foreach (var resource in Resources)
             {
-                resourceModel.Delete(resource);
+                resourceModel.DeleteResource(resource);
             }
             ResourceTypeModel resourceTypeModel = new ResourceTypeModel();
             foreach (var resourceType in ResourceTypes)
@@ -257,8 +316,11 @@ namespace Coscine.Api.Project.Tests
             InstituteModel instituteModel = new InstituteModel();
             instituteModel.Delete(Institute);
 
-            VisibilityModel visibilityModel = new VisibilityModel();
-            visibilityModel.Delete(Visibility);
+            LicenseModel licenseModel = new LicenseModel();
+            licenseModel.Delete(License);
+
+            RDSResourceTypeModel rdsResourceTypeModel = new RDSResourceTypeModel();
+            rdsResourceTypeModel.Delete(RdsResourceType);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Project.Tests/Project.Tests.csproj b/src/Project.Tests/Project.Tests.csproj
index 420a64b56b96cf9066fd86de45627885dea3076a..e8ef3ee396d34678d05f483e3731da2091c18e7d 100644
--- a/src/Project.Tests/Project.Tests.csproj
+++ b/src/Project.Tests/Project.Tests.csproj
@@ -565,6 +565,7 @@
     <Compile Include="ProjectControllerTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ResourceControllerTests.cs" />
+    <Compile Include="ResourceTypeControllerTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />
diff --git a/src/Project.Tests/ProjectControllerTests.cs b/src/Project.Tests/ProjectControllerTests.cs
index 8188c11910f6b72716c37c7830dfa1d57a09fa6c..d58925000986501d2e1309460d8766664cde61ec 100644
--- a/src/Project.Tests/ProjectControllerTests.cs
+++ b/src/Project.Tests/ProjectControllerTests.cs
@@ -132,13 +132,7 @@ namespace Coscine.Api.Project.Tests
 
             ProjectModel projectModel = new ProjectModel();
             var project = projectModel.GetById(createdProjectObject.Id);
-            ProjectRoleModel projectRoleModel = new ProjectRoleModel();
-            var projectRoles = projectRoleModel.GetAllWhere((x) => x.ProjectId == project.Id);
-            foreach (var projectRole in projectRoles)
-            {
-                projectRoleModel.Delete(projectRole);
-            }
-            projectModel.Delete(project);
+            Controller.DeleteProject(project);
         }
 
 
@@ -261,32 +255,7 @@ namespace Coscine.Api.Project.Tests
 
             ProjectModel projectModel = new ProjectModel();
             var project = projectModel.GetById(createdProjectObject.Id);
-
-            SubProjectModel subProjectModel1 = new SubProjectModel();
-            var subProjects1 = subProjectModel1.GetAllWhere((x) => x.ProjectId == project.Id);
-            foreach (var subProject in subProjects1)
-            {
-                subProjectModel1.Delete(subProject);
-            }
-
-            ProjectRoleModel projectRoleModel = new ProjectRoleModel();
-            var projectRoles = projectRoleModel.GetAllWhere((x) => x.ProjectId == project.Id);
-            foreach (var projectRole in projectRoles)
-            {
-                projectRoleModel.Delete(projectRole);
-            }
-
-            projectModel.Delete(project);
-
-            ProjectModel projectModel2 = new ProjectModel();
-            var project2 = projectModel2.GetById(createdSubProjectObject.Id);
-            ProjectRoleModel projectRoleModel2 = new ProjectRoleModel();
-            var projectRoles2 = projectRoleModel2.GetAllWhere((x) => x.ProjectId == project2.Id);
-            foreach (var projectRole in projectRoles2)
-            {
-                projectRoleModel2.Delete(projectRole);
-            }
-            projectModel2.Delete(project2);
+            Controller.DeleteProject(project);
         }
 
         [Test]
diff --git a/src/Project.Tests/ResourceControllerTests.cs b/src/Project.Tests/ResourceControllerTests.cs
index 67e82d31c40da7bf346b1c21bd2e9f5fcbddda23..405547449e2a26fd9ca3b517baeba52a03878b6a 100644
--- a/src/Project.Tests/ResourceControllerTests.cs
+++ b/src/Project.Tests/ResourceControllerTests.cs
@@ -4,8 +4,10 @@ using Coscine.Api.Project.ReturnObjects;
 using Coscine.ApiCommons.Exceptions;
 using Coscine.ApiCommons.Factories;
 using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json.Linq;
 using NUnit.Framework;
 using System;
+using System.Collections.Generic;
 using System.IO;
 
 namespace Coscine.Api.Project.Tests
@@ -33,13 +35,13 @@ namespace Coscine.Api.Project.Tests
             OkObjectResult okObjectResult = (OkObjectResult)actionResult;
             Assert.IsTrue(okObjectResult.Value.GetType() == typeof(ResourceObject));
 
-            ResourceObject projectObject = (ResourceObject)okObjectResult.Value;
+            ResourceObject resourceObject = (ResourceObject)okObjectResult.Value;
 
-            Assert.IsTrue(projectObject.Id == Resources[0].Id);
-            Assert.IsTrue(projectObject.ExternalId == Resources[0].ExternalId);
-            Assert.IsTrue(projectObject.Type.Id == Resources[0].Type.Id);
-            Assert.IsTrue(projectObject.Type.DisplayName == Resources[0].Type.DisplayName);
-            Assert.IsTrue(projectObject.Url == Resources[0].Url);
+            Assert.IsTrue(resourceObject.Id == Resources[0].Id);
+            Assert.IsTrue(resourceObject.DisplayName == Resources[0].DisplayName);
+            Assert.IsTrue(resourceObject.Visibility.DisplayName == Resources[0].Visibility.DisplayName);
+            Assert.IsTrue(resourceObject.Type.Id == Resources[0].Type.Id);
+            Assert.IsTrue(resourceObject.Type.DisplayName == Resources[0].Type.DisplayName);
         }
 
 
@@ -50,7 +52,8 @@ namespace Coscine.Api.Project.Tests
             OkObjectResult okObjectResult = (OkObjectResult)actionResult;
             ResourceObject resourceObject = (ResourceObject)okObjectResult.Value;
 
-            resourceObject.ExternalId = "ChangedExternalId";
+            resourceObject.DisplayName = "OtherName";
+            resourceObject.ResourceTypeOption = JObject.FromObject(new RDSResourceTypeObject(Guid.NewGuid(), "PITLABTTEST", "accesskey", "secretkey"));
 
             Stream stream = ObjectFactory<ResourceObject>.SerializeToStream(resourceObject);
 
@@ -83,7 +86,18 @@ namespace Coscine.Api.Project.Tests
         [Test]
         public void TestControllerStoreToProject()
         {
-            ResourceObject resourceObject = new ResourceObject(Guid.NewGuid(), "externalId", "http://rwth-aachen.de/newTest", "TestResource", new ResourceTypeObject(ResourceTypes[0].Id, ResourceTypes[0].DisplayName));
+            ResourceObject resourceObject = new ResourceObject(
+                Guid.NewGuid(),
+                "Test",
+                "testR",
+                "keys",
+                "usageR",
+                new ResourceTypeObject(Resources[0].Type.Id, Resources[0].Type.DisplayName),
+                new List<DisciplineObject>() { new DisciplineObject(Discipline.Id, Discipline.Url, Discipline.DisplayName) },
+                new VisibilityObject(Visibility.Id, Visibility.DisplayName),
+                new LicenseObject(License.Id, License.DisplayName),
+                JObject.FromObject(new RDSResourceTypeObject(Guid.NewGuid(), "PITLABTTEST", "accesskey", "secretkey"))
+            );
 
             Stream stream = ObjectFactory<ResourceObject>.SerializeToStream(resourceObject);
 
@@ -97,16 +111,14 @@ namespace Coscine.Api.Project.Tests
             // Cleanup
             stream.Close();
 
-            ResourceModel resourceModel = new ResourceModel();
-            var resource = resourceModel.GetById(resourceObject.Id);
+            stream = ObjectFactory<ResourceObject>.SerializeToStream(resourceObject);
 
-            ProjectResourceModel projectResourceModel = new ProjectResourceModel();
-            foreach(var projectResource in projectResourceModel.GetAllWhere((projectResource) => projectResource.ProjectId == Projects[0].Id && projectResource.ResourceId == resource.Id))
-            {
-                projectResourceModel.Delete(projectResource);
-            }
+            FakeControllerContext(Users[0], stream);
+
+            actionResult = Controller.Delete(resourceObject.Id.ToString());
+            Assert.IsTrue(actionResult.GetType() == typeof(OkObjectResult));
 
-            resourceModel.Delete(resource);
+            stream.Close();
         }
     }
 }
diff --git a/src/Project.Tests/ResourceTypeControllerTests.cs b/src/Project.Tests/ResourceTypeControllerTests.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c2262a54e713b39d76f93df8d4cdc9425841098c
--- /dev/null
+++ b/src/Project.Tests/ResourceTypeControllerTests.cs
@@ -0,0 +1,39 @@
+using Coscine.Api.Project.Controllers;
+using Microsoft.AspNetCore.Mvc;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Coscine.Api.Project.Tests
+{
+    [TestFixture]
+    public class ResourceTypeControllerTests : DefaultControllerTests<ResourceTypeController>
+    {
+        public ResourceTypeControllerTests() : base(new ResourceTypeController())
+        {
+        }
+
+        [Test]
+        public void TestGettingFields()
+        {
+            var actionResult = Controller.Fields(Resources[0].Type.Id.ToString());
+            Assert.IsTrue(actionResult.GetType() == typeof(OkObjectResult));
+
+            OkObjectResult okObjectResult = (OkObjectResult)actionResult;
+            List<string> fields = (List<string>) okObjectResult.Value;
+            if(fields.Count() == 3)
+            {
+                Assert.IsTrue(fields[0] == "BucketName");
+                Assert.IsTrue(fields[1] == "AccessKey");
+                Assert.IsTrue(fields[2] == "SecretKey");
+            }
+            else
+            {
+                Assert.Fail("Wrong field count!");
+            }
+        }
+    }
+}
diff --git a/src/Project/Controllers/DataSourceController.cs b/src/Project/Controllers/DataSourceController.cs
index 26b4944897321702e4d4a9b3b84981f53eca5e82..cd24c50db54ad68ce63aee27fb42778fa99269b3 100644
--- a/src/Project/Controllers/DataSourceController.cs
+++ b/src/Project/Controllers/DataSourceController.cs
@@ -75,11 +75,17 @@ namespace Coscine.Api.Project.Controllers
 
             if (resource.Type.DisplayName.ToLower() == "rds")
             {
-                authHeader = BuildRdsAuthHeader(resource.ExternalId);
+                RDSResourceTypeModel rdsResourceTypeModel = new RDSResourceTypeModel();
+                var rdsResourceType = rdsResourceTypeModel.GetById(resource.ResourceTypeOptionId.Value);
+
+                authHeader = BuildRdsAuthHeader(rdsResourceType);
             }
             else if (resource.Type.DisplayName.ToLower() == "gitlab")
             {
-                authHeader = BuildGitlabAuthHeader(resource.ExternalId, resource.Url);
+                GitlabResourceTypeModel gitlabResourceTypeModel = new GitlabResourceTypeModel();
+                var gitlabResourceType = gitlabResourceTypeModel.GetById(resource.ResourceTypeOptionId.Value);
+
+                authHeader = BuildGitlabAuthHeader(gitlabResourceType);
             }
 
             if (authHeader != null)
@@ -146,39 +152,39 @@ namespace Coscine.Api.Project.Controllers
             return _jwtHandler.GenerateJwtToken(payload);
         }
 
-        private string BuildRdsAuthHeader(string bucketname)
+        private string BuildRdsAuthHeader(RDSResourceType rdsResourceType)
         {
             var auth = new Dictionary<string, object>();
 
             var credentials = new Dictionary<string, object>
             {
-                { "access_key", _configuration.GetString("coscine/global/rds_access_key") },
-                { "secret_key", _configuration.GetString("coscine/global/rds_secret_key") }
+                { "access_key", rdsResourceType.AccessKey },
+                { "secret_key", rdsResourceType.SecretKey }
             };
 
             var settings = new Dictionary<string, object>
             {
-                { "bucket", bucketname }
+                { "bucket", rdsResourceType.BucketName }
             };
 
             return BuildWaterbutlerPayload(auth, credentials, settings);
         }
 
-        private string BuildGitlabAuthHeader(string externalId, string url)
+        private string BuildGitlabAuthHeader(GitlabResourceType gitlabResourceType)
         {
 
             var auth = new Dictionary<string, object>();
 
             var credentials = new Dictionary<string, object>
             {
-                { "token", _configuration.GetString("coscine/global/gitlabtoken") }
+                { "token", gitlabResourceType.Token }
             };
 
             var settings = new Dictionary<string, object>
             {
                 {"owner", "Tester"},
-                {"repo", url},
-                { "repo_id", externalId},
+                { "repo", gitlabResourceType.RepositoryUrl},
+                { "repo_id", gitlabResourceType.RepositoryNumber},
                 { "host", "https://git.rwth-aachen.de"}
             };
 
diff --git a/src/Project/Controllers/ProjectController.cs b/src/Project/Controllers/ProjectController.cs
index 005457084d1fe31364fc258eecb7a6ea59ce0aa7..8ac5cbdaf020c022312ebb46d186d23def32b987 100644
--- a/src/Project/Controllers/ProjectController.cs
+++ b/src/Project/Controllers/ProjectController.cs
@@ -78,12 +78,7 @@ namespace Coscine.Api.Project.Controllers
                             select projectResource).Any())
                             .Select((resource) =>
                             {
-                                ResourceType resourceType = resource.Type;
-                                if (resourceType == null)
-                                {
-                                    resourceType = resourceTypeModel.GetById(resource.TypeId);
-                                }
-                                return new ResourceObject(resource.Id, resource.ExternalId, resource.Url, resource.DisplayName, new ResourceTypeObject(resourceType.Id, resourceType.DisplayName));
+                                return resourceModel.CreateReturnObjectFromDatabaseObject(resource);
                             });
                 }
                 else
@@ -129,7 +124,7 @@ namespace Coscine.Api.Project.Controllers
             }));
         }
 
-        private void DeleteProject(Coscine.Database.Model.Project project)
+        public void DeleteProject(Coscine.Database.Model.Project project)
         {
             SubProjectModel subProjectModel = new SubProjectModel();
             foreach(var subProject in subProjectModel.GetAllWhere((subProject) => subProject.ProjectId == project.Id))
@@ -138,6 +133,11 @@ namespace Coscine.Api.Project.Controllers
                 DeleteProject(_projectModel.GetById(subProject.SubProjectId));
             }
 
+            foreach (var subProject in subProjectModel.GetAllWhere((subProject) => subProject.SubProjectId == project.Id))
+            {
+                subProjectModel.Delete(subProject);
+            }
+
             ProjectResourceModel projectResourceModel = new ProjectResourceModel();
             ResourceModel resourceModel = new ResourceModel();
             foreach (var projectResource in projectResourceModel.GetAllWhere((projectResource) => projectResource.ProjectId == project.Id))
@@ -164,7 +164,17 @@ namespace Coscine.Api.Project.Controllers
                 projectInstituteModel.Delete(projectInstitute);
             }
 
-            FireEvents((projectAction, projectEventArgs) => projectAction.OnProjectDelete(project, projectEventArgs));
+            FireEvents((projectAction, projectEventArgs) =>
+            {
+                try
+                {
+                    projectAction.OnProjectDelete(project, projectEventArgs);
+                }
+                catch (Exception)
+                {
+                    // Filter exception, because sometimes the PID or SharePoint site might not be generated in e.g. tests 
+                }
+            });
 
             _projectModel.Delete(project);
         }
diff --git a/src/Project/Controllers/ResourceController.cs b/src/Project/Controllers/ResourceController.cs
index 4041baabece14383293e63acb9715788243744d8..27c3e13350e3e317c4db119ef305b17022c059b0 100644
--- a/src/Project/Controllers/ResourceController.cs
+++ b/src/Project/Controllers/ResourceController.cs
@@ -3,6 +3,7 @@ using Coscine.Api.Project.ReturnObjects;
 using Coscine.ApiCommons;
 using Coscine.ApiCommons.Exceptions;
 using Coscine.ApiCommons.Factories;
+using Coscine.Database.Model;
 using Microsoft.AspNetCore.Mvc;
 using System;
 using System.Linq;
@@ -32,7 +33,7 @@ namespace Coscine.Api.Project.Controllers
                                    && projectRole.Role.DisplayName == "Owner"
                                    select projectRole).Any()
                             select projectResource).Any()
-                ).Select((resource) => new ResourceObject(resource.Id, resource.ExternalId, resource.Url, resource.DisplayName, new ResourceTypeObject(resource.Type.Id, resource.Type.DisplayName)));
+                ).Select((resource) => _resourceModel.CreateReturnObjectFromDatabaseObject(resource));
             }));
         }
 
@@ -45,13 +46,8 @@ namespace Coscine.Api.Project.Controllers
                 var resource = _resourceModel.GetById(Guid.Parse(id));
                 if (_resourceModel.OwnsResource(user, resource))
                 {
-                    //TODO: Find out why resource.Type is not set
-                    if(resource.Type == null)
-                    {
-                        ResourceTypeModel resourceTypeModel = new ResourceTypeModel();
-                        resource.Type = resourceTypeModel.GetById(resource.TypeId);
-                    }
-                    return new ResourceObject(resource.Id, resource.ExternalId, resource.Url, resource.DisplayName, new ResourceTypeObject(resource.Type.Id, resource.Type.DisplayName));
+                    _resourceModel.SetType(resource);
+                    return _resourceModel.CreateReturnObjectFromDatabaseObject(resource);
                 }
                 else
                 {
@@ -78,6 +74,25 @@ namespace Coscine.Api.Project.Controllers
             }));
         }
 
+        [HttpDelete("[controller]/{id}")]
+        public IActionResult Delete(string id)
+        {
+            return Ok(_authenticator.ValidateAndExecute((user) =>
+            {
+                var resource = _resourceModel.GetById(Guid.Parse(id));
+                if (_resourceModel.OwnsResource(user, resource))
+                {
+                    var returnObject = _resourceModel.CreateReturnObjectFromDatabaseObject(resource);
+                    _resourceModel.DeleteResource(resource);
+                    return returnObject;
+                }
+                else
+                {
+                    throw new NotAuthorizedException("The user is not authorized to perform an update on the selected resource!");
+                }
+            }));
+        }
+
         [HttpPost("[controller]/project/{projectId}")]
         public IActionResult StoreToProject(string projectId)
         {
@@ -93,7 +108,7 @@ namespace Coscine.Api.Project.Controllers
 
                     projectModel.AddResource(project, resource);
 
-                    return new ResourceObject(resource.Id, resource.ExternalId, resource.Url, resource.DisplayName, new ResourceTypeObject(resource.Type.Id, resource.Type.DisplayName));
+                    return _resourceModel.CreateReturnObjectFromDatabaseObject(resource);
                 }
                 else
                 {
diff --git a/src/Project/Controllers/ResourceTypeController.cs b/src/Project/Controllers/ResourceTypeController.cs
index e4425d7ae2fbad7b92cd4681c91dc7a2b41a8333..fd5179b7c8900ad4edf844b4b4bece01486e91c1 100644
--- a/src/Project/Controllers/ResourceTypeController.cs
+++ b/src/Project/Controllers/ResourceTypeController.cs
@@ -31,5 +31,33 @@ namespace Coscine.Api.Project.Controllers
             }));
         }
 
+        [Route("[controller]/{id}/fields")]
+        public IActionResult Fields(string id)
+        {
+            return Ok(_authenticator.ValidateAndExecute((user) =>
+            {
+                var resourceType = _resourceTypeModel.GetById(Guid.Parse(id));
+
+                if(resourceType.DisplayName == "rds")
+                {
+                    return Type.GetType("Coscine.Api.Project.ReturnObjects.RDSResourceTypeObject").GetProperties()
+                            .Where((property) => property.Name != "Id")
+                            .Select((property) => property.Name)
+                            .ToList();
+                }
+                else if(resourceType.DisplayName == "gitlab")
+                {
+                    return Type.GetType("Coscine.Api.Project.ReturnObjects.GitlabResourceTypeObject").GetProperties()
+                            .Where((property) => property.Name != "Id")
+                            .Select((property) => property.Name)
+                            .ToList();
+                }
+                else
+                {
+                    throw new ArgumentException("Invalid Resource Type!");
+                }
+            }));
+        }
+
     }   
 }
diff --git a/src/Project/Models/GitlabResourceTypeModel.cs b/src/Project/Models/GitlabResourceTypeModel.cs
new file mode 100644
index 0000000000000000000000000000000000000000..5ca0c42d79d9df46873439c032bbe5dcd5939c81
--- /dev/null
+++ b/src/Project/Models/GitlabResourceTypeModel.cs
@@ -0,0 +1,35 @@
+using Coscine.ApiCommons.Models;
+using Coscine.Database.Model;
+using LinqToDB;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Coscine.Api.Project.Models
+{
+    public class GitlabResourceTypeModel : DatabaseModel<GitlabResourceType>
+    {
+        public GitlabResourceTypeModel() : base(Program.Configuration)
+        {
+
+        }
+
+        public override Expression<Func<GitlabResourceType, Guid>> GetIdFromObject()
+        {
+            return (gitlabResourceType) => gitlabResourceType.Id;
+        }
+
+        public override ITable<GitlabResourceType> GetITableFromDatabase(CoscineDB db)
+        {
+            return db.GitlabResourceTypes;
+        }
+
+        public override void SetObjectId(GitlabResourceType databaseObject, Guid id)
+        {
+            databaseObject.Id = id;
+        }
+    }
+}
diff --git a/src/Project/Models/LicenseModel.cs b/src/Project/Models/LicenseModel.cs
new file mode 100644
index 0000000000000000000000000000000000000000..40d914335be4e575d12479f1c6888a5acc2cd4e2
--- /dev/null
+++ b/src/Project/Models/LicenseModel.cs
@@ -0,0 +1,33 @@
+using Coscine.ApiCommons.Models;
+using Coscine.Database.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Coscine.Api.Project.Models
+{
+    public class LicenseModel : DatabaseModel<License>
+    {
+        public LicenseModel() : base(Program.Configuration)
+        {
+
+        }
+
+        public override System.Linq.Expressions.Expression<Func<License, Guid>> GetIdFromObject()
+        {
+            return (license) => license.Id;
+        }
+
+        public override LinqToDB.ITable<License> GetITableFromDatabase(CoscineDB db)
+        {
+            return db.Licenses;
+        }
+
+        public override void SetObjectId(License databaseObject, Guid id)
+        {
+            databaseObject.Id = id;
+        }
+    }
+}
diff --git a/src/Project/Models/RDSResourceTypeModel.cs b/src/Project/Models/RDSResourceTypeModel.cs
new file mode 100644
index 0000000000000000000000000000000000000000..d8aada145190e475d40fc7d7e5ff1ef437bdd03c
--- /dev/null
+++ b/src/Project/Models/RDSResourceTypeModel.cs
@@ -0,0 +1,35 @@
+using Coscine.ApiCommons.Models;
+using Coscine.Database.Model;
+using LinqToDB;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Coscine.Api.Project.Models
+{
+    public class RDSResourceTypeModel : DatabaseModel<RDSResourceType>
+    {
+        public RDSResourceTypeModel() : base(Program.Configuration)
+        {
+
+        }
+
+        public override Expression<Func<RDSResourceType, Guid>> GetIdFromObject()
+        {
+            return (rdsResourceType) => rdsResourceType.Id;
+        }
+
+        public override ITable<RDSResourceType> GetITableFromDatabase(CoscineDB db)
+        {
+            return db.RDSResourceTypes;
+        }
+
+        public override void SetObjectId(RDSResourceType databaseObject, Guid id)
+        {
+            databaseObject.Id = id;
+        }
+    }
+}
diff --git a/src/Project/Models/ResourceDisciplineModel.cs b/src/Project/Models/ResourceDisciplineModel.cs
new file mode 100644
index 0000000000000000000000000000000000000000..8dbfc92b4da52fc31e2bf2f59c78144f473dbf50
--- /dev/null
+++ b/src/Project/Models/ResourceDisciplineModel.cs
@@ -0,0 +1,35 @@
+using Coscine.ApiCommons.Models;
+using Coscine.Database.Model;
+using LinqToDB;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Coscine.Api.Project.Models
+{
+    public class ResourceDisciplineModel : DatabaseModel<ResourceDiscipline>
+    {
+        public ResourceDisciplineModel() : base(Program.Configuration)
+        {
+
+        }
+
+        public override Expression<Func<ResourceDiscipline, Guid>> GetIdFromObject()
+        {
+            return (resourceDiscipline) => resourceDiscipline.RelationId;
+        }
+
+        public override ITable<ResourceDiscipline> GetITableFromDatabase(CoscineDB db)
+        {
+            return db.ResourceDisciplines;
+        }
+
+        public override void SetObjectId(ResourceDiscipline databaseObject, Guid id)
+        {
+            databaseObject.RelationId = id;
+        }
+    }
+}
diff --git a/src/Project/Models/ResourceModel.cs b/src/Project/Models/ResourceModel.cs
index dedb396c4b33615eacb67a204ab57614a0724551..c1ff1877a51940b59b29a06546d899c66f43375f 100644
--- a/src/Project/Models/ResourceModel.cs
+++ b/src/Project/Models/ResourceModel.cs
@@ -2,7 +2,9 @@
 using Coscine.ApiCommons.Models;
 using Coscine.Database.Model;
 using LinqToDB;
+using Newtonsoft.Json.Linq;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 
@@ -17,18 +19,137 @@ namespace Coscine.Api.Project.Models
 
         public Resource StoreFromObject(ResourceObject resourceObject)
         {
-            Resource resource = new Resource()
+            if (resourceObject.Disciplines.Count() == 0 || resourceObject.ResourceTypeOption == null)
             {
-                ExternalId = resourceObject.ExternalId,
-                Url = resourceObject.Url,
+                throw new ArgumentException("Discipline and ResourceTypeOption are necessary!");
+            }
+
+            Resource resource = new Resource()
+            {                
                 DisplayName = resourceObject.DisplayName,
+                ResourceName = resourceObject.ResourceName,
+                Keywords = resourceObject.Keywords,
+                UsageRights = resourceObject.UsageRights,
                 TypeId = resourceObject.Type.Id,
-                Type = new ResourceTypeModel().GetById(resourceObject.Type.Id)
+                Type = new ResourceTypeModel().GetById(resourceObject.Type.Id),
+                VisibilityId = resourceObject.Visibility.Id,
+                LicenseId = resourceObject.License.Id
             };
             Insert(resource);
+            
+            try
+            {
+                SetDisciplines(resource, resourceObject.Disciplines);
+                SetResourceTypeObject(resource, resourceObject.ResourceTypeOption);
+            }
+            catch (Exception e)
+            {
+                Delete(resource);
+                throw e;
+            }
+
             return resource;
         }
 
+        public int DeleteResource(Resource resource)
+        {
+            ProjectResourceModel projectResourceModel = new ProjectResourceModel();
+            foreach (var projectResource in projectResourceModel.GetAllWhere((projectResource) => projectResource.ResourceId == resource.Id))
+            {
+                projectResourceModel.Delete(projectResource);
+            }
+
+            ResourceDisciplineModel resourceDisciplineModel = new ResourceDisciplineModel();
+            foreach (var resourceDiscipline in resourceDisciplineModel.GetAllWhere((resourceDicipline) => resourceDicipline.ResourceId == resource.Id))
+            {
+                resourceDisciplineModel.Delete(resourceDiscipline);
+            }
+
+            DeleteResourceTypeObject(resource);
+
+            return Delete(resource);
+        }
+
+        private void SetResourceTypeObject(Resource resource, JObject resourceTypeOption)
+        {
+            if (resource.Type.DisplayName == "rds")
+            {
+                RDSResourceTypeObject rdsResourceTypeObject = resourceTypeOption.ToObject<RDSResourceTypeObject>();
+                RDSResourceTypeModel rdsResourceTypeModel = new RDSResourceTypeModel();
+                if (resource.ResourceTypeOptionId != null)
+                {
+                    RDSResourceType rdsResourceType = rdsResourceTypeModel.GetById(resource.ResourceTypeOptionId.Value);
+
+                    rdsResourceType.BucketName = rdsResourceTypeObject.BucketName;
+                    rdsResourceType.AccessKey = rdsResourceTypeObject.AccessKey ?? rdsResourceType.AccessKey;
+                    rdsResourceType.SecretKey = rdsResourceTypeObject.SecretKey ?? rdsResourceType.SecretKey;
+
+                    rdsResourceTypeModel.Update(rdsResourceType);
+                }
+                else
+                {
+                    RDSResourceType rdsResourceType = new RDSResourceType()
+                    {
+                        BucketName = rdsResourceTypeObject.BucketName,
+                        AccessKey = rdsResourceTypeObject.AccessKey,
+                        SecretKey = rdsResourceTypeObject.SecretKey
+                    };
+                    rdsResourceTypeModel.Insert(rdsResourceType);
+                    resource.ResourceTypeOptionId = rdsResourceType.Id;
+                    Update(resource);
+                }
+            }
+            else if (resource.Type.DisplayName == "gitlab")
+            {
+                GitlabResourceTypeObject gitlabResourceTypeObject = resourceTypeOption.ToObject<GitlabResourceTypeObject>();
+                GitlabResourceTypeModel gitlabResourceTypeModel = new GitlabResourceTypeModel();
+                if (resource.ResourceTypeOptionId != null)
+                {
+                    GitlabResourceType gitlabResourceType = gitlabResourceTypeModel.GetById(resource.ResourceTypeOptionId.Value);
+
+                    gitlabResourceType.RepositoryNumber = gitlabResourceTypeObject.RepositoryNumber;
+                    gitlabResourceType.RepositoryUrl = gitlabResourceTypeObject.RepositoryUrl;
+                    gitlabResourceType.Token = gitlabResourceTypeObject.Token ?? gitlabResourceType.Token;
+
+                    gitlabResourceTypeModel.Update(gitlabResourceType);
+                }
+                else
+                {
+                    GitlabResourceType gitlabResourceType = new GitlabResourceType()
+                    {
+                        RepositoryNumber = gitlabResourceTypeObject.RepositoryNumber,
+                        RepositoryUrl = gitlabResourceTypeObject.RepositoryUrl,
+                        Token = gitlabResourceTypeObject.Token
+                    };
+                    gitlabResourceTypeModel.Insert(gitlabResourceType);
+                    resource.ResourceTypeOptionId = gitlabResourceType.Id;
+                    Update(resource);
+                }
+            }
+            else
+            {
+                throw new ArgumentException("Not supported resource type!");
+            }
+        }
+
+        private void SetDisciplines(Resource resource, IEnumerable<DisciplineObject> disciplines)
+        {
+            ResourceDisciplineModel resourceDisciplineModel = new ResourceDisciplineModel();
+            foreach (var oldDiscipline in resourceDisciplineModel.GetAllWhere((resourceDiscipline) => resourceDiscipline.ResourceId == resource.Id))
+            {
+                resourceDisciplineModel.Delete(oldDiscipline);
+            }
+            foreach (var discipline in disciplines)
+            {
+                ResourceDiscipline resourceDiscipline = new ResourceDiscipline()
+                {
+                    DisciplineId = discipline.Id,
+                    ResourceId = resource.Id
+                };
+                resourceDisciplineModel.Insert(resourceDiscipline);
+            }
+        }
+
         public bool OwnsResource(User user, Resource resource)
         {
             return DatabaseConnection.ConnectToDatabase((db) =>
@@ -41,6 +162,109 @@ namespace Coscine.Api.Project.Models
                         select relation).Any();
             });
         }
+               
+        public int UpdateByObject(Resource resource, ResourceObject resourceObject)
+        {
+            if (resourceObject.Disciplines.Count() == 0 || resourceObject.ResourceTypeOption == null)
+            {
+                throw new ArgumentException("Discipline and ResourceTypeOption are necessary!");
+            }
+
+            if (resource.TypeId != resourceObject.Type.Id)
+            {
+                DeleteResourceTypeObject(resource);
+            }
+
+            resource.DisplayName = resourceObject.DisplayName;
+            resource.ResourceName = resourceObject.ResourceName;
+            resource.Keywords = resourceObject.Keywords;
+            resource.UsageRights = resourceObject.UsageRights;
+            resource.TypeId = resourceObject.Type.Id;
+            resource.Type = new ResourceTypeModel().GetById(resourceObject.Type.Id);
+            resource.VisibilityId = resourceObject.Visibility.Id;
+            resource.LicenseId = resourceObject.License.Id;
+
+            SetDisciplines(resource, resourceObject.Disciplines);
+            SetResourceTypeObject(resource, resourceObject.ResourceTypeOption);
+
+            return Update(resource);
+        }
+
+        // TODO: Find out why resource.Type is not set
+        public void SetType(Resource resource)
+        {
+            if (resource.Type == null)
+            {
+                ResourceTypeModel resourceTypeModel = new ResourceTypeModel();
+                resource.Type = resourceTypeModel.GetById(resource.TypeId);
+            }
+        }
+
+        public void DeleteResourceTypeObject(Resource resource)
+        {
+            SetType(resource);
+            if (resource.Type.DisplayName == "rds" && resource.ResourceTypeOptionId != null)
+            {
+                RDSResourceTypeModel rdsResourceTypeModel = new RDSResourceTypeModel();
+                rdsResourceTypeModel.Delete(rdsResourceTypeModel.GetById(resource.ResourceTypeOptionId.Value));
+            }
+            else if (resource.Type.DisplayName == "gitlab" && resource.ResourceTypeOptionId != null)
+            {
+                GitlabResourceTypeModel gitlabResourceTypeModel = new GitlabResourceTypeModel();
+                gitlabResourceTypeModel.Delete(gitlabResourceTypeModel.GetById(resource.ResourceTypeOptionId.Value));
+            }
+        }
+
+        public ResourceObject CreateReturnObjectFromDatabaseObject(Resource resource)
+        {
+            SetType(resource);
+
+            DisciplineModel disciplineModel = new DisciplineModel();
+            var disciplines = disciplineModel.GetAllWhere((discipline) =>
+                            (from relation in discipline.ResourceDisciplineDisciplineIdIds
+                             where relation.ResourceId == resource.Id
+                             select relation).Any())
+                            .Select((discipline) => new DisciplineObject(discipline.Id, discipline.Url, discipline.DisplayName));
+
+            if (resource.Visibility == null && resource.VisibilityId != null)
+            {
+                VisibilityModel visibilityModel = new VisibilityModel();
+                resource.Visibility = visibilityModel.GetById(resource.VisibilityId.Value);
+            }
+
+            if (resource.License == null && resource.LicenseId != null)
+            {
+                LicenseModel licenseModel = new LicenseModel();
+                resource.License = licenseModel.GetById(resource.LicenseId.Value);
+            }
+
+            ResourceTypeOptionObject resourceTypeOptionObject = null;
+            if(resource.Type.DisplayName == "rds" && resource.ResourceTypeOptionId != null)
+            {
+                RDSResourceTypeModel rdsResourceTypeModel = new RDSResourceTypeModel();
+                var rdsResourceType = rdsResourceTypeModel.GetById(resource.ResourceTypeOptionId.Value);
+                resourceTypeOptionObject = new RDSResourceTypeObject(rdsResourceType.Id, rdsResourceType.BucketName, null, null);
+            }
+            else if(resource.Type.DisplayName == "gitlab" && resource.ResourceTypeOptionId != null)
+            {
+                GitlabResourceTypeModel gitlabResourceTypeModel = new GitlabResourceTypeModel();
+                var gitlabResourceType = gitlabResourceTypeModel.GetById(resource.ResourceTypeOptionId.Value);
+                resourceTypeOptionObject = new GitlabResourceTypeObject(gitlabResourceType.Id, gitlabResourceType.RepositoryNumber, gitlabResourceType.RepositoryUrl, null);
+            }
+
+            return new ResourceObject(
+                resource.Id,
+                resource.DisplayName,
+                resource.ResourceName,
+                resource.Keywords,
+                resource.UsageRights,
+                new ResourceTypeObject(resource.Type.Id, resource.Type.DisplayName),
+                disciplines,
+                (resource.Visibility != null) ? new VisibilityObject(resource.Visibility.Id, resource.Visibility.DisplayName) : null,
+                (resource.License != null) ? new LicenseObject(resource.License.Id, resource.License.DisplayName) : null,
+                JObject.FromObject(resourceTypeOptionObject)
+            );
+        }
 
         public override Expression<Func<Resource, Guid>> GetIdFromObject()
         {
@@ -56,14 +280,5 @@ namespace Coscine.Api.Project.Models
         {
             databaseObject.Id = id;
         }
-
-        public int UpdateByObject(Resource resource, ResourceObject resourceObject)
-        {
-            resource.ExternalId = resourceObject.ExternalId;
-            resource.TypeId = resourceObject.Type.Id;
-            resource.Url = resourceObject.Url;
-
-            return Update(resource);
-        }
     }
 }
diff --git a/src/Project/Project.csproj b/src/Project/Project.csproj
index e37d8ab911cb8e2811dc180ec408809930e2b575..504cbdd6d942f0ec8c60a96cceb7ff0cde01b756 100644
--- a/src/Project/Project.csproj
+++ b/src/Project/Project.csproj
@@ -577,12 +577,16 @@
     <Compile Include="Controllers\SubProjectController.cs" />
     <Compile Include="Controllers\ProjectRoleController.cs" />
     <Compile Include="Models\DisciplineModel.cs" />
+    <Compile Include="Models\GitlabResourceTypeModel.cs" />
     <Compile Include="Models\InstituteModel.cs" />
+    <Compile Include="Models\LicenseModel.cs" />
     <Compile Include="Models\ProjectDisciplineModel.cs" />
     <Compile Include="Models\ProjectInstituteModel.cs" />
     <Compile Include="Models\ProjectModel.cs" />
     <Compile Include="Models\ProjectResourceModel.cs" />
     <Compile Include="Models\ProjectRoleModel.cs" />
+    <Compile Include="Models\RDSResourceTypeModel.cs" />
+    <Compile Include="Models\ResourceDisciplineModel.cs" />
     <Compile Include="Models\ResourceModel.cs" />
     <Compile Include="Models\ResourceTypeModel.cs" />
     <Compile Include="Models\RoleModel.cs" />
@@ -591,6 +595,10 @@
     <Compile Include="Models\VisibilityModel.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ReturnObjects\GitlabResourceTypeObject.cs" />
+    <Compile Include="ReturnObjects\LicenseObject.cs" />
+    <Compile Include="ReturnObjects\RDSResourceTypeObject.cs" />
+    <Compile Include="ReturnObjects\ResourceTypeOptionObject.cs" />
     <Compile Include="ReturnObjects\VisibilityObject.cs" />
     <Compile Include="ReturnObjects\InstituteObject.cs" />
     <Compile Include="ReturnObjects\DisciplineObject.cs" />
diff --git a/src/Project/ReturnObjects/GitlabResourceTypeObject.cs b/src/Project/ReturnObjects/GitlabResourceTypeObject.cs
new file mode 100644
index 0000000000000000000000000000000000000000..54d2189b64f2f606b7b67b283843394d151cc9e6
--- /dev/null
+++ b/src/Project/ReturnObjects/GitlabResourceTypeObject.cs
@@ -0,0 +1,22 @@
+using System;
+
+namespace Coscine.Api.Project.ReturnObjects
+{
+    [Serializable]
+    public class GitlabResourceTypeObject : ResourceTypeOptionObject
+    {
+        public Guid Id { get; set; }
+
+        public int RepositoryNumber { get; set; }
+        public string RepositoryUrl { get; set; }
+        public string Token { get; set; }
+
+        public GitlabResourceTypeObject(Guid id, int repositoryNumber, string repositoryUrl, string token)
+        {
+            Id = id;
+            RepositoryNumber = repositoryNumber;
+            RepositoryUrl = repositoryUrl;
+            Token = token;
+        }
+    }
+}
diff --git a/src/Project/ReturnObjects/LicenseObject.cs b/src/Project/ReturnObjects/LicenseObject.cs
new file mode 100644
index 0000000000000000000000000000000000000000..16f617bb1c98d86d8a982094c8cc03a101376a6b
--- /dev/null
+++ b/src/Project/ReturnObjects/LicenseObject.cs
@@ -0,0 +1,19 @@
+using Coscine.ApiCommons.ReturnObjects;
+using System;
+
+namespace Coscine.Api.Project.ReturnObjects
+{
+    [Serializable]
+    public class LicenseObject : IReturnObject
+    {
+        public Guid Id { get; set; }
+
+        public string DisplayName { get; set; }
+
+        public LicenseObject(Guid id, string displayName)
+        {
+            Id = id;
+            DisplayName = displayName;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Project/ReturnObjects/RDSResourceTypeObject.cs b/src/Project/ReturnObjects/RDSResourceTypeObject.cs
new file mode 100644
index 0000000000000000000000000000000000000000..35d846842e81252c167469d38c375892307b0b04
--- /dev/null
+++ b/src/Project/ReturnObjects/RDSResourceTypeObject.cs
@@ -0,0 +1,22 @@
+using System;
+
+namespace Coscine.Api.Project.ReturnObjects
+{
+    [Serializable]
+    public class RDSResourceTypeObject : ResourceTypeOptionObject
+    {
+        public Guid Id { get; set; }
+        public string BucketName { get; set; }
+        public string AccessKey { get; set; }
+        public string SecretKey { get; set; }
+
+        public RDSResourceTypeObject(Guid id, string bucketName, string accessKey, string secretKey)
+        {
+            Id = id;
+            BucketName = bucketName;
+
+            AccessKey = accessKey;
+            SecretKey = secretKey;
+        }
+    }
+}
diff --git a/src/Project/ReturnObjects/ResourceObject.cs b/src/Project/ReturnObjects/ResourceObject.cs
index 87ad7bafea3c36a6bcd2c07b5c56ff319cc21139..c8c6264636fcde0e394e984c8e6c5383a4abc56b 100644
--- a/src/Project/ReturnObjects/ResourceObject.cs
+++ b/src/Project/ReturnObjects/ResourceObject.cs
@@ -1,5 +1,7 @@
 using Coscine.ApiCommons.ReturnObjects;
+using Newtonsoft.Json.Linq;
 using System;
+using System.Collections.Generic;
 
 namespace Coscine.Api.Project.ReturnObjects
 {
@@ -7,20 +9,31 @@ namespace Coscine.Api.Project.ReturnObjects
     public class ResourceObject : IReturnObject
     {
         public Guid Id { get; set; }
-
-        public string ExternalId { get; set; }
-        public string Url { get; set; }
         public string DisplayName { get; set; }
-
+        public string ResourceName { get; set; }
+        public string Keywords { get; set; }
+        public string UsageRights { get; set; }
         public ResourceTypeObject Type { get; set; }
+        public IEnumerable<DisciplineObject> Disciplines { get; set; }
+        public VisibilityObject Visibility { get; set; }
+        public LicenseObject License { get; set; }
+        public JObject ResourceTypeOption { get; set; }
 
-        public ResourceObject(Guid id, string externalId, string url, string displayName, ResourceTypeObject type)
+        public ResourceObject(Guid id,  string displayName, string resourceName, string keywords, string usageRights, ResourceTypeObject type, IEnumerable<DisciplineObject> disciplines, VisibilityObject visibility, LicenseObject license, JObject resourceTypeOption)
         {
             Id = id;
-            ExternalId = externalId;
-            Url = url;
+
             DisplayName = displayName;
+            ResourceName = resourceName;
+            Keywords = keywords;
+            UsageRights = usageRights;
+            
             Type = type;
+            Disciplines = disciplines;
+            Visibility = visibility;
+            License = license;
+
+            ResourceTypeOption = resourceTypeOption;
         }
     }
 }
diff --git a/src/Project/ReturnObjects/ResourceTypeOptionObject.cs b/src/Project/ReturnObjects/ResourceTypeOptionObject.cs
new file mode 100644
index 0000000000000000000000000000000000000000..194e529afebb74835a45b9a045a2663703edba63
--- /dev/null
+++ b/src/Project/ReturnObjects/ResourceTypeOptionObject.cs
@@ -0,0 +1,10 @@
+using Coscine.ApiCommons.ReturnObjects;
+using System;
+
+namespace Coscine.Api.Project.ReturnObjects
+{
+    [Serializable]
+    public abstract class ResourceTypeOptionObject : IReturnObject
+    {
+    }
+}
\ No newline at end of file