Merge remote-tracking branch 'remotes/origin/master' into Product/801-refactorFileMetadata

docs/ESLintConvention.md

-## ESLint Convention
-
-Make the changes to the code and tests and then commit to your branch. Be sure to follow the commit message conventions.
-
-Commit message summaries must follow this basic format:
-
-```
-Tag: Message (fixes #1234)
-```
-
-`Tag` should not be confused with git tag.
-`Message` should not be confused with git commit message.
-
-The `Tag` is one of the following:
-
-* `Fix` - for a bug fix.
-* `Update` - for a backwards-compatible enhancement.
-* `Breaking` - for a backwards-incompatible enhancement.
-* `Docs` - changes to documentation only.
-* `Build` - changes to build process only.
-* `New` - implemented a new feature.
-* `Upgrade` - for a dependency upgrade.
-
-The message summary should be a one-sentence description of the change. The issue number should be mentioned at the end. * The commit message should say "(fixes #1234)" at the end of the description if it closes out an existing issue (replace 1234 with the issue number). If the commit doesn't completely fix the issue, then use `(refs #1234)` instead of `(fixes #1234)`.
-
-Here are some good commit message summary examples:
-
-```
-Build: Update Travis to only test Node 0.10 (refs #734)
-Fix: Semi rule incorrectly flagging extra semicolon (fixes #840)
-Upgrade: Esprima to 1.2, switch to using Esprima comment attachment (fixes #730)
-```
-
-The commit message format is important because these messages are used to create a changelog for each release. The tag and issue number help to create more consistent and useful changelogs.
-
-Based on https://github.com/eslint/eslint.github.io/blob/master/docs/developer-guide/contributing.md#step-2-make-your-changes
-
-[npm-image]: https://badge.fury.io/js/conventional-changelog-eslint.svg
-[npm-url]: https://npmjs.org/package/conventional-changelog-eslint
-[travis-image]: https://travis-ci.org/stevemao/conventional-changelog-eslint.svg?branch=master
-[travis-url]: https://travis-ci.org/stevemao/conventional-changelog-eslint
-[daviddm-image]: https://david-dm.org/stevemao/conventional-changelog-eslint.svg?theme=shields.io
-[daviddm-url]: https://david-dm.org/stevemao/conventional-changelog-eslint
-[coveralls-image]: https://coveralls.io/repos/stevemao/conventional-changelog-eslint/badge.svg
-[coveralls-url]: https://coveralls.io/r/stevemao/conventional-changelog-eslint
\ No newline at end of file

docs/home.md

-## C# Database ORM and FluentMigrator
-
-We provide a data model generated using linq2DB, allowing us to access our database via linq.
-A migration tool based on fluent migrator is used for stable and reversible database migrations.
-
-
-## Data Model
-linq2db generates the code that eventually creates the data model by compiling a design time text template.
-The main file for the text compilation is the /DataModel/CsDatabase.tt file. In that file, the database connection information should be provided. Follow the instructions in that file for working with the datamodel.
-
-The data model will be generated on every build process for the project guaranteering an up-to-date state of the data model with respect to migrations. The builer in this case is MSBuild, which does not know relative paths used by linqToDB. That means, if, for instance, some library changes require changes to the text compilation process from the text templates, you need to register the path variables used by linqToDB by unloading and editing the CsDatabase.proj!
-
-### Using the data model in your project
-Other than including this project, you need to set the configuration string for linqToDb to establish a connection to your database.
-You must call the constructor for the data model object with the server provider name and the connection string.
-The connection string has the format: "Data Source={dbDataSource}; Database={dbDatabase}; User Id={dbUserId}; Password={dbPassword};".
-The provider name is "SqlServer.2008" for our projects. A list of valid alternative names can be found here: https://linq2db.github.io/api/LinqToDB.ProviderName.html
-For an example look at the unit test in CsDatabase.Tests/ModelTest.cs
-
-### Changing the target of the data model
-If you want to change the database for which the data model should be created, you need to make a few adjustments:
- - The namespace should be adjusted in
-   - cs-database/DataModel/CsDatabase.tt
-   - cs-database/DataModelConstructor.ttinclude
- - The name of the partial class in cs-database/DataModelConstructor.ttinclude
- - The configuration string for the database connection will, by default, be fetched from consul. If needed, change the consul query keys in:
-   - cs-database/DatabaseConnection.ttinclude
-   - Migrator/Migrator.cs
- - If you are connecting a database other than msserver, you also must swap the
- It is recommended to include the cs-database/DataModelConstructor.ttinclude so that the database connection can be established with a programmatically obtained connection string (e.g. using consul) rather than having to include a App.config file to your projects.
- - Furhtermore you need to adapt the right _providerName in:
-   - CsDatabase.Tests/ModelTest.cs
-   - your projects
-
-## Fluent Migrator
-The fluent migrator provides a command line tool for handling database migrations.
-Currently, it provides an intermediary interface for utilizing the fluentMigrator up migration (down migration is currently not supported by us) as well as its rollback function, using the command line arguments:
-```
--migrate_up
--roll_back <number of roll back steps>
-```
-FluentMigrator will look for migrations in the Migrations directory. While it is, in principle, possible to call the our migrator from other projects as well, it is recommended to have all migrations in this project for greater cohesion and in order to make sure that the data model stays up-to-date.
-Migrations should be identified by a unique id which corresponds, roughly, to the date and time of its implementation. The format is:
-```
-YYYYMMDDhhmm
-```
-FluentMigrator uses this identifier to manage its migration versioning. For an example migration, check out the migrations in the test project for the database.
\ No newline at end of file

docs/markup.md

-It's very easy to make some words **bold** and other words *italic* with Markdown. You can even [link to Google!](http://google.com)
-
-Sometimes you want numbered lists:
-
-1. One
-2. Two
-3. Three
-
-Sometimes you want bullet points:
-
-* Start a line with a star
-* Profit!
-
-Alternatively,
-
-- Dashes work just as well
-- And if you have sub points, put two spaces before the dash or star:
-  - Like this
-  - And this
-
-If you want to embed images, this is how you do it:
-
-![Image of Yaktocat](https://octodex.github.com/images/yaktocat.png)
-
-# Structured documents
-
-Sometimes it's useful to have different levels of headings to structure your documents. Start lines with a `#` to create headings. Multiple `##` in a row denote smaller heading sizes.
-
-### This is a third-tier heading
-
-You can use one `#` all the way up to `######` six for different heading sizes.
-
-If you'd like to quote someone, use the > character before the line:
-
-> Coffee. The finest organic suspension ever devised... I beat the Borg with it.
-> - Captain Janeway
-
-[200~There are many different ways to style code with GitHub's markdown. If you have inline code blocks, wrap them in backticks: `var example = true`.  If you've got a longer block of code, you can indent with four spaces:
-
-    if (isAwesome){
-      return true
-    }
-
-GitHub also supports something called code fencing, which allows for multiple lines without indentation:
-
-```
-if (isAwesome){
-  return true
-}
-```
-
-And if you'd like to use syntax highlighting, include the language:
-
-```javascript
-if (isAwesome){
-  return true
-}
-```
-
-GitHub supports many extras in Markdown that help you reference and link to people. If you ever want to direct a comment at someone, you can prefix their name with an @ symbol: Hey @kneath — love your sweater!
-
-But I have to admit, tasks lists are my favorite:
-
-- [x] This is a complete item
-- [ ] This is an incomplete item
-
-When you include a task list in the first comment of an Issue, you will see a helpful progress bar in your list of issues. It works in Pull Requests, too!
-
-And, of course emoji!
-GitHub supports many extras in Markdown that help you reference and link to people. If you ever want to direct a comment at someone, you can prefix their name with an @ symbol: Hey @kneath — love your sweater!
-
-But I have to admit, tasks lists are my favorite:
-
- This is a complete item
- This is an incomplete item
-When you include a task list in the first comment of an Issue, you will see a helpful progress bar in your list of issues. It works in Pull Requests, too!
-
-And, of course emoji!

docs/nunit.md

-## Add NUnit Tests
-
-### Add Nunit test adapter
-1.  Choose **Tools > Extensions and Updates**
-2.  In the **Extensions and Updates** dialog box, expand the **Online** category and then **Visual Studio Marketplace**. Then, choose **Tools > Testing**.
-2.  Select the **NUnit test adapter** and then choose **Download.**
-### Add Tests
-
-1.  Create a class library project and add it to your solution.
-
-    For convinience name it like your main project and add **.Tests** as a suffix.
-    ![alt text](images/create_class_library.png "Select Class Library")
-
-2.  Install the plug-in. In **Solution Explorer**, select the class library project, and then choose **Manage NuGet Packages** from its right-click or context menu.
-
-    ![alt text](images/add_a_package.png "Add a package")
-
-3.  In the **NuGet Package Manager** window, search for and select the plug-in (NUnit), and then choose **Install**.
-    ![alt text](images/select_framework.png "Select Project")
-
-    The framework is now referenced in your project under **References**.
-
-4.  From the class library project's **References** node, select **Add Reference**.
-
-    ![alt text](images/add_a_reference.png "Add a reference")
-
-5. In the **Reference Manager** dialog box, select the project that contains the code you'll test.
-
-    ![alt text](images/select_project.png "Select Project")
-
-6. Code your unit test.
-    
-    ![alt text](images/test_code.png "Test Code")

src/Database.Tests/Properties/AssemblyInfo.cs

@@ -9,8 +9,8 @@ using System.Reflection;
 [assembly: AssemblyDescription("Database.Tests is a part of the CoScInE group.")]
 [assembly: AssemblyCompany("IT Center, RWTH Aachen University")]
 [assembly: AssemblyProduct("Database.Tests")]
-[assembly: AssemblyVersion("1.18.1")]
-[assembly: AssemblyFileVersion("1.18.1")]
-[assembly: AssemblyInformationalVersion("1.18.1-topic-712-organi0004")]
+[assembly: AssemblyVersion("1.20.0")]
+[assembly: AssemblyFileVersion("1.20.0")]
+[assembly: AssemblyInformationalVersion("1.20.0-topic-758-userpr0007")]
 [assembly: AssemblyCopyright("2020 IT Center, RWTH Aachen University")]
 

src/Database/Database.csproj

@@ -64,6 +64,7 @@
     <Reference Include="System" />
     <Reference Include="System.ComponentModel.DataAnnotations" />
     <Reference Include="System.Core" />
+    <Reference Include="System.DirectoryServices" />
     <Reference Include="System.Net.Http.WebRequest" />
     <Reference Include="System.Web" />
     <Reference Include="System.Xml.Linq" />
@@ -79,15 +80,20 @@
     <Compile Include="Models\ExternalAuthenticatorModel.cs" />
     <Compile Include="Models\ExternalIdModel.cs" />
     <Compile Include="Models\FeaturesModel.cs" />
+    <Compile Include="Models\ProjectQuotasModel.cs" />
+    <Compile Include="Models\TOSModel.cs" />
     <Compile Include="ReturnObjects\ActivatedFeatureObject.cs" />
     <Compile Include="Models\LogModel.cs" />
     <Compile Include="ReturnObjects\DisciplineObject.cs" />
+    <Compile Include="ReturnObjects\ExternalAuthenticatorsObject.cs" />
     <Compile Include="ReturnObjects\FeatureObject.cs" />
     <Compile Include="ReturnObjects\GitlabResourceTypeObject.cs" />
     <Compile Include="ReturnObjects\IReturnObject.cs" />
+    <Compile Include="ReturnObjects\LanguageObject.cs" />
     <Compile Include="ReturnObjects\LicenseObject.cs" />
     <Compile Include="ReturnObjects\OrganizationObject.cs" />
     <Compile Include="ReturnObjects\ProjectObject.cs" />
+    <Compile Include="ReturnObjects\ProjectQuotaObject.cs" />
     <Compile Include="ReturnObjects\ProjectRoleObject.cs" />
     <Compile Include="ReturnObjects\RDSResourceTypeObject.cs" />
     <Compile Include="ReturnObjects\ResourceObject.cs" />
@@ -95,6 +101,7 @@
     <Compile Include="ReturnObjects\ResourceTypeOptionObject.cs" />
     <Compile Include="ReturnObjects\RoleObject.cs" />
     <Compile Include="ReturnObjects\S3ResourceTypeObject.cs" />
+    <Compile Include="ReturnObjects\TitleObject.cs" />
     <Compile Include="ReturnObjects\UserObject.cs" />
     <Compile Include="ReturnObjects\VisibilityObject.cs" />
     <Compile Include="ReturnObjects\WaterbutlerFolder.cs" />
@@ -119,6 +126,7 @@
     <Compile Include="Models\DatabaseModel.cs" />
     <Compile Include="Models\DisciplineModel.cs" />
     <Compile Include="Models\GitlabResourceTypeModel.cs" />
+    <Compile Include="Models\LanguageModel.cs" />
     <Compile Include="Models\LicenseModel.cs" />
     <Compile Include="Models\MetadataModel.cs" />
     <Compile Include="Models\ProjectDisciplineModel.cs" />
@@ -133,7 +141,9 @@
     <Compile Include="Models\RoleModel.cs" />
     <Compile Include="Models\S3ResourceTypeModel.cs" />
     <Compile Include="Models\SubProjectModel.cs" />
+    <Compile Include="Models\TitleModel.cs" />
     <Compile Include="Models\UserModel.cs" />
+    <Compile Include="Models\UserDisciplineModel.cs" />
     <Compile Include="Models\VisibilityModel.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

src/Database/Models/LanguageModel.cs

+using Coscine.Database.DataModel;
+using System;
+
+namespace Coscine.Database.Models
+{
+    public class LanguageModel : DatabaseModel<Language>
+    {
+        public override System.Linq.Expressions.Expression<Func<Language, Guid>> GetIdFromObject()
+        {
+            return (language) => language.Id;
+        }
+
+        public override LinqToDB.ITable<Language> GetITableFromDatabase(CoscineDB db)
+        {
+            return db.Languages;
+        }
+
+        public override void SetObjectId(Language databaseObject, Guid id)
+        {
+            databaseObject.Id = id;
+        }
+    }
+}

src/Database/Models/ProjectModel.cs

@@ -7,6 +7,7 @@ using Coscine.Database.DataModel;
 using LinqToDB;
 using Coscine.Database.Util;
 using LinqKit;
+using System.Text.RegularExpressions;
 
 namespace Coscine.Database.Models
 {
@@ -37,6 +38,11 @@ namespace Coscine.Database.Models
             });
         }
 
+        public Project GetBySlug(String slug)
+        {
+            return GetWhere((tableEntry) => tableEntry.Slug == slug);
+        }
+
         public Project GetByIdIncludingDeleted(Guid id)
         {
             var expression = GetIdFromObject();
@@ -144,6 +150,7 @@ namespace Coscine.Database.Models
                 ProjectName = projectObject.ProjectName,
                 PrincipleInvestigators = projectObject.PrincipleInvestigators,
                 GrantId = projectObject.GrantId,
+                Slug = GenerateSlug(projectObject),
 
                 VisibilityId = projectObject.Visibility.Id,
             };
@@ -152,6 +159,7 @@ namespace Coscine.Database.Models
             {
                 SetDisciplines(project, projectObject.Disciplines);
                 SetOrganizations(project, projectObject.Organizations);
+                SetQuotas(project);
             }
             catch (Exception e)
             {
@@ -162,6 +170,41 @@ namespace Coscine.Database.Models
             return project;
         }
 
+        private String GenerateSlug(ProjectObject projectObject)
+        {
+            // create slug for project
+            var slug = projectObject.DisplayName;
+            slug = slug.ToLower();
+            slug = Regex.Replace(slug, @"[\s-]+", "-");
+            slug = Regex.Replace(slug, @"[^a-z0-9-]*|", "");
+            slug = Regex.Replace(slug, @"^-|-$", "");
+
+            Random r = new Random();
+            int rInt = r.Next(0, 9000000) + 1000000;
+            string fullSlug = "" + rInt;
+
+            if (slug.Length >= 7)
+            {
+                rInt = r.Next(0, 9000) + 1000;
+                fullSlug = slug;
+            }
+
+            if (GetBySlug(fullSlug) != null)
+            {
+                if (slug.Length >= 7)
+                {
+                    fullSlug = slug + "-";
+                }
+                while (GetBySlug(fullSlug + rInt) != null)
+                {
+                    rInt++;
+                };
+                fullSlug += rInt;
+            }
+
+            return fullSlug;
+        }
+
         private void SetDisciplines(Project project, IEnumerable<DisciplineObject> disciplines)
         {
             ProjectDisciplineModel projectDisciplineModel = new ProjectDisciplineModel();
@@ -196,6 +239,21 @@ namespace Coscine.Database.Models
             }
         }
 
+        private void SetQuotas(Project project)
+        {
+            ProjectQuotaModel projectQuotaModel = new ProjectQuotaModel();
+            ResourceTypeModel resourceTypeModel = new ResourceTypeModel();
+            foreach (var resourceType in resourceTypeModel.GetAll())
+            {
+                projectQuotaModel.Insert(new ProjectQuota
+                {
+                    ProjectId = project.Id,
+                    ResourceTypeId = resourceType.Id,
+                    Quota = 25
+                });
+            }
+        }
+
         public ProjectRole SetOwner(Project project, User user)
         {
             ProjectRoleModel projectRoleModel = new ProjectRoleModel();
@@ -332,6 +390,7 @@ namespace Coscine.Database.Models
                                                     disciplines,
                                                     organizations,
                                                     project.Visibility == null ? null : new VisibilityObject(project.Visibility.Id, project.Visibility.DisplayName),
+                                                    project.Slug,
                                                     parentId);
         }
 
@@ -382,7 +441,6 @@ namespace Coscine.Database.Models
             return projectList;
         }
 
-
         public override Expression<Func<Project, Guid>> GetIdFromObject()
         {
             return databaseObject => databaseObject.Id;

src/Database/Models/ProjectQuotasModel.cs

+using Coscine.Database.DataModel;
+using Coscine.Database.ReturnObjects;
+using LinqToDB;
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+
+namespace Coscine.Database.Models
+{
+    public class ProjectQuotaModel : DatabaseModel<ProjectQuota>
+    {
+        public ProjectQuotaObject CreateReturnObjectFromDatabaseObject(ProjectQuota projectQuota)
+        {
+            if (projectQuota.ResourceType == null)
+            {
+                ResourceTypeModel resourceTypeModel = new ResourceTypeModel();
+                projectQuota.ResourceType = resourceTypeModel.GetById(projectQuota.ResourceTypeId);
+            }
+
+            return new ProjectQuotaObject(
+                projectQuota.RelationId,
+                projectQuota.ProjectId,
+                new ResourceTypeObject(
+                    projectQuota.ResourceType.Id,
+                    projectQuota.ResourceType.DisplayName,
+                    projectQuota.ResourceType.Enabled
+                ),
+                projectQuota.Quota
+            );
+        }
+
+        public override Expression<Func<ProjectQuota, Guid>> GetIdFromObject()
+        {
+            return (projectQuota) => projectQuota.RelationId;
+        }
+
+        public override ITable<ProjectQuota> GetITableFromDatabase(CoscineDB db)
+        {
+            return db.ProjectQuotas;
+        }
+
+        public override void SetObjectId(ProjectQuota databaseObject, Guid id)
+        {
+            databaseObject.RelationId = id;
+        }
+    }
+}

src/Database/Models/TOSModel.cs

+using Coscine.Database.DataModel;
+using LinqToDB;
+using System;
+using System.Linq.Expressions;
+
+namespace Coscine.Database.Models
+{
+    public class TOSModel : DatabaseModel<TOSAccepted>
+    {
+        public override Expression<Func<TOSAccepted, Guid>> GetIdFromObject()
+        {
+            return (tosAccepted) => tosAccepted.RelationId;
+        }
+
+        public override ITable<TOSAccepted> GetITableFromDatabase(CoscineDB db)
+        {
+            return db.TOSAccepteds;
+        }
+
+        public override void SetObjectId(TOSAccepted databaseObject, Guid id)
+        {
+            databaseObject.RelationId = id;
+        }
+    }
+}

src/Database/Models/TitleModel.cs

+using Coscine.Database.DataModel;
+using LinqToDB;
+using System;
+using System.Linq.Expressions;
+
+namespace Coscine.Database.Models
+{
+    public class TitleModel : DatabaseModel<Title>
+    {
+        public override Expression<Func<Title, Guid>> GetIdFromObject()
+        {
+            return (title) => title.Id;
+        }
+
+        public override ITable<Title> GetITableFromDatabase(CoscineDB db)
+        {
+            return db.Titles;
+        }
+
+        public override void SetObjectId(Title databaseObject, Guid id)
+        {
+            databaseObject.Id = id;
+        }
+    }
+}

src/Database/Models/UserDisciplineModel.cs

+using Coscine.Database.DataModel;
+using LinqToDB;
+using System;
+using System.Linq.Expressions;
+
+namespace Coscine.Database.Models
+{
+    public class UserDisciplineModel : DatabaseModel<UserDiscipline>
+    {
+        public override Expression<Func<UserDiscipline, Guid>> GetIdFromObject()
+        {
+            return (userDiscipline) => userDiscipline.RelationId;
+        }
+
+        public override ITable<UserDiscipline> GetITableFromDatabase(CoscineDB db)
+        {
+            return db.UserDisciplines;
+        }
+
+        public override void SetObjectId(UserDiscipline databaseObject, Guid id)
+        {
+            databaseObject.RelationId = id;
+        }
+    }
+}

src/Database/Models/UserModel.cs

-using Coscine.Database.DataModel;
+using Coscine.Configuration;
+using Coscine.Database.DataModel;
+using Coscine.Database.ReturnObjects;
+using Coscine.Database.Util;
 using LinqToDB;
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 
 namespace Coscine.Database.Models
@@ -21,5 +26,86 @@ namespace Coscine.Database.Models
         {
             databaseObject.Id = Id;
         }
+
+        public UserObject CreateReturnObjectFromDatabaseObject(User user)
+        {
+            IEnumerable<DisciplineObject> disciplines = new List<DisciplineObject>();
+            if (user.UserDisciplinesUserIdIds == null)
+            {
+                DisciplineModel disciplineModel = new DisciplineModel();
+                disciplines = disciplineModel.GetAllWhere((discipline) => (from relation in discipline.UserDisciplinesDisciplineIdIds where relation.UserId == user.Id select relation).Any())
+                                                .Select((discipline) => new DisciplineObject(discipline.Id, discipline.Url, discipline.DisplayNameDe, discipline.DisplayNameEn));
+            }
+            else
+            {
+                disciplines = user.UserDisciplinesUserIdIds.Select((discipline) => new DisciplineObject(discipline.Discipline.Id, discipline.Discipline.Url, discipline.Discipline.DisplayNameDe, discipline.Discipline.DisplayNameEn));
+            }
+
+            var externalAuthenticatorModel = new ExternalAuthenticatorModel();
+            var externalAuthenticators = externalAuthenticatorModel.GetAllWhere(
+                (externalAuthenticator) => 
+                    (from relation in externalAuthenticator.ExternalIdsResourceTypeIdIds
+                        where relation.UserId == user.Id select relation).Any())
+                        .Select((externalAuthenticator) => 
+                            new ExternalAuthenticatorsObject(
+                                externalAuthenticator.Id, externalAuthenticator.DisplayName));
+
+            if (user.Title == null && user.TitleId.HasValue)
+            {
+                TitleModel titleModel = new TitleModel();
+                user.Title = titleModel.GetById(user.TitleId.Value);
+            }
+
+            if (user.Language == null && user.LanguageId.HasValue)
+            {
+                LanguageModel languageModel = new LanguageModel();
+                user.Language = languageModel.GetById(user.LanguageId.Value);
+            }
+
+            return new UserObject(
+                user.Id,
+                user.DisplayName,
+                user.Givenname,
+                user.Surname,
+                user.EmailAddress,
+                false,
+                user.Title == null ? null : new TitleObject(user.Title.Id, user.Title.DisplayName),
+                user.Language == null ? null : new LanguageObject(user.Language.Id, user.Language.DisplayName, user.Language.Abbreviation),
+                user.Organization,
+                user.Institute,
+                disciplines,
+                false,
+                externalAuthenticators);
+        }
+
+        public int UpdateByObject(User user, UserObject userObject)
+        {
+            user.TitleId = userObject.Title?.Id;
+            user.Givenname = userObject.Givenname;
+            user.Surname = userObject.Surname;
+            user.DisplayName = userObject.DisplayName;            
+            user.Organization = userObject.Organization;
+            user.Institute = userObject.Institute;
+            user.LanguageId = userObject.Language?.Id;
+            SetDisciplines(user, userObject.Disciplines);
+            return Update(user);
+        }
+
+        private void SetDisciplines(User user, IEnumerable<DisciplineObject> disciplines)
+        {
+            UserDisciplineModel userDisciplineModel = new UserDisciplineModel();
+            foreach (var oldDiscipline in userDisciplineModel.GetAllWhere((userDiscipline) => userDiscipline.UserId == user.Id))
+            {
+                userDisciplineModel.Delete(oldDiscipline);
+            }
+            foreach (var discipline in disciplines)
+            {
+                userDisciplineModel.Insert(new UserDiscipline()
+                {
+                    UserId = user.Id,
+                    DisciplineId = discipline.Id
+                });
+            }
+        }
     }
 }