fix

MyOffice.Core/Extensions/GuidExtensions.cs

@@ -6,4 +6,15 @@ public static class GuidExtensions
 	{
 		return guid.ToString().EqualsIgnoreCase(str);
 	}
+
+	public static string ToShort(this Guid guid)
+	{
+		/*string encoded = Convert.ToBase64String(guid.ToByteArray());
+		encoded = encoded
+			.Replace("/", "_")
+			.Replace("+", "-");
+
+		return encoded.Substring(0, 22);*/
+		return guid.ToString("N");
+	}
 }

MyOffice.Core/Extensions/StringExtensions.cs

@@ -1,5 +1,7 @@
 namespace MyOffice.Core.Extensions;
 
+using Microsoft.Extensions.Logging;
+
 public static class StringExtensions
 {
 	public static bool IsMissing(this string? str)
@@ -26,4 +28,28 @@ public static class StringExtensions
 	{
 		return true.ToString().Equals(str, StringComparison.OrdinalIgnoreCase) || defaultValue;
 	}
+
+	public static Guid AsGuid(this string str)
+	{
+		/*str = str
+			.Replace("_", "/")
+			.Replace("-", "+");
+		byte[] buffer = Convert.FromBase64String(str + "==");
+		return new Guid(buffer);*/
+		return Guid.Parse(str);
+	}
+
+	public static Guid? AsGuidNull(this string str)
+	{
+		/*str = str
+			.Replace("_", "/")
+			.Replace("-", "+");
+		byte[] buffer = Convert.FromBase64String(str + "==");
+		return new Guid(buffer);*/
+		if (Guid.TryParse(str, out var guid))
+		{
+			return guid;
+		}
+		return null;
+	}
 }

MyOffice.Core/Helpers/JsonHelper.cs

@@ -0,0 +1,31 @@
+namespace MyOffice.Core.Helpers
+{
+	using System.Text.Json;
+	using System.Text.Json.Serialization;
+
+	public static class JsonHelper
+	{
+		public static string ToJson(this object entity, JsonSerializerOptions? options = null)
+		{
+			options ??= new JsonSerializerOptions
+			{
+				MaxDepth = 0,
+				DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+				ReferenceHandler = ReferenceHandler.IgnoreCycles,
+				WriteIndented = true,
+			};
+			return JsonSerializer.Serialize(entity, options);
+		}
+	}
+
+	/*public class CustomIgnoreReferenceHandler : ReferenceHandler
+	{
+		//public CustomIgnoreReferenceHandler() => HandlingStrategy = ReferenceHandlingStrategy.IgnoreCycles;
+		public CustomIgnoreReferenceHandler()
+		{
+			new HandlingStrategy { } = true;
+		}
+
+		public override ReferenceResolver CreateResolver() => new IgnoreReferenceResolver();
+	}*/
+}

MyOffice.Data.Models/Accounts/Account.cs

@@ -1,70 +1,22 @@
-namespace MyOffice.Data.Models.Account;
+namespace MyOffice.Data.Models.Accounts;
 
-using MyOffice.Data.Models.Users;
+using Currencies;
-
-public class CurrencyGlobal
-{
-	public string Id { get; set; }
-	public string Name { get; set; }
-	public string ShortName { get; set; }
-	public IEnumerable<Currency>? Currencies { get; set; }
-	public IEnumerable<Account>? Accounts { get; set; }
-}
-
-public class Currency
-{
-	public Guid Id { get; set; }
-	public string CurrencyGlobalId { get; set; }
-	public CurrencyGlobal? CurrencyGlobal { get; set; }
-	public Guid UserId { get; set; }
-	public User? User { get; set; }
-
-	public string Name { get; set; }
-	public string ShortName { get; set; }
-	public IEnumerable<CurrencyRate>? Rates { get; set; }
-}
-
-public class CurrencyRate
-{
-	public int Id { get; set; }
-	public Guid CurrencyId { get; set; }
-	public Currency? Currency { get; set; }
-	public DateTime DateTime { get; set; }
-	public decimal Rate { get; set; }
-}
 
 public class Account
 {
 	public Guid Id { get; set; }
-	public string CurrencyGlobalId { get; set; }
+	public string CurrencyGlobalId { get; set; } = null!;
 	public CurrencyGlobal? CurrencyGlobal { get; set; }
-	public string Name { get; set; }
+	public string Name { get; set; } = null!;
-	public IEnumerable<AccountAccess> AccessRights { get; set; }
+	public IEnumerable<AccountAccess>? AccessRights { get; set; }
-	public IEnumerable<AccountMotion> Motions { get; set; }
+	public IEnumerable<AccountMotion>? Motions { get; set; }
+	public IEnumerable<AccountAccountCategory>? Categories { get; set; }
 }
 
-public class AccountAccess
+public class AccountDetailed
 {
-	public int Id { get; set; }
+	public Account Account { get; set; } = null!;
-	public Guid AccountId { get; set; }
+	public decimal TotalPlus { get; set; }
-	public Account? Account { get; set; }
+	public decimal TotalMinus { get; set; }
-	public Guid UserId { get; set; }
+	public decimal Rest => TotalPlus - TotalMinus;
-	public User? User { get; set; }
-	
-	public bool IsAllowRead { get; set; }
-	public bool IsAllowWrite { get; set; }
-	public bool IsAllowManage { get; set; }
-}
-
-public class AccountMotion
-{
-	public long Id { get; set; }
-	public DateTime CreatedOn { get; set; }
-	public DateTime DateTime { get; set; }
-	public Guid AccountId { get; set; }
-	public Account? Account { get; set; }
-	public Guid UserId { get; set; }
-	public User? User { get; set; }
-	public decimal AmountIn { get; set; }
-	public decimal AmountOut { get; set; }
 }

MyOffice.Data.Models/Accounts/AccountAccess.cs

@@ -0,0 +1,16 @@
+namespace MyOffice.Data.Models.Accounts;
+
+using MyOffice.Data.Models.Users;
+
+public class AccountAccess
+{
+	public int Id { get; set; }
+	public Guid AccountId { get; set; }
+	public Account? Account { get; set; }
+	public Guid UserId { get; set; }
+	public User? User { get; set; }
+	
+	public bool IsAllowRead { get; set; }
+	public bool IsAllowWrite { get; set; }
+	public bool IsAllowManage { get; set; }
+}

MyOffice.Data.Models/Accounts/AccountAccountCategory.cs

@@ -0,0 +1,10 @@
+namespace MyOffice.Data.Models.Accounts;
+
+public class AccountAccountCategory
+{
+	public int Id { get; set; }
+	public Guid AccountId { get; set; }
+	public Account Account { get; set; } = null!;
+	public Guid CategoryId { get; set; }
+	public AccountCategory Category { get; set; } = null!;
+}

MyOffice.Data.Models/Accounts/AccountCategory.cs

@@ -0,0 +1,12 @@
+namespace MyOffice.Data.Models.Accounts;
+
+using MyOffice.Data.Models.Users;
+
+public class AccountCategory
+{
+	public Guid Id { get; set; }
+	public Guid UserId { get; set; }
+	public User? User { get; set; }
+	public string Name { get; set; } = null!;
+	public IEnumerable<AccountAccountCategory>? Accounts { get; set; }
+}

MyOffice.Data.Models/Accounts/AccountMotion.cs

@@ -0,0 +1,17 @@
+namespace MyOffice.Data.Models.Accounts;
+
+using MyOffice.Data.Models.Motions;
+
+public class AccountMotion
+{
+	public long Id { get; set; }
+	public DateTime CreatedOn { get; set; }
+	public DateTime DateTime { get; set; }
+	public int MotionId { get; set; }
+	public MotionAccount Motion { get; set; } = null!;
+	public Guid AccountId { get; set; }
+	public Account Account { get; set; } = null!;
+	public string? Description { get; set; }
+	public decimal AmountPlus { get; set; }
+	public decimal AmountMinus { get; set; }
+}

MyOffice.Data.Models/Currencies/Currency.cs

@@ -0,0 +1,16 @@
+namespace MyOffice.Data.Models.Currencies;
+
+using MyOffice.Data.Models.Users;
+
+public class Currency
+{
+	public Guid Id { get; set; }
+	public string CurrencyGlobalId { get; set; } = null!;
+	public CurrencyGlobal? CurrencyGlobal { get; set; }
+	public Guid UserId { get; set; }
+	public User? User { get; set; }
+
+	public string Name { get; set; } = null!;
+	public string ShortName { get; set; } = null!;
+	public IEnumerable<CurrencyRate>? Rates { get; set; }
+}

MyOffice.Data.Models/Currencies/CurrencyGlobal.cs

@@ -0,0 +1,13 @@
+namespace MyOffice.Data.Models.Currencies;
+
+using MyOffice.Data.Models.Accounts;
+
+public class CurrencyGlobal
+{
+	public string Id { get; set; } = null!;
+	public string Name { get; set; } = null!;
+	public string Symbol { get; set; } = null!;
+	public int DefaultQuantity { get; set; }
+	public IEnumerable<Currency>? Currencies { get; set; }
+	public IEnumerable<Account>? Accounts { get; set; }
+}

MyOffice.Data.Models/Currencies/CurrencyRate.cs

@@ -0,0 +1,11 @@
+namespace MyOffice.Data.Models.Currencies;
+
+public class CurrencyRate
+{
+	public int Id { get; set; }
+	public Guid CurrencyId { get; set; }
+	public Currency? Currency { get; set; }
+	public DateTime DateTime { get; set; }
+	public int Quantity { get; set; }
+	public decimal Rate { get; set; }
+}

MyOffice.Data.Models/Motions/MotionAccount.cs

@@ -0,0 +1,13 @@
+namespace MyOffice.Data.Models.Motions;
+
+using Accounts;
+
+public class MotionAccount
+{
+	public int Id { get; set; }
+	public Guid CategoryId { get; set; }
+	public MotionCategory Category { get; set; } = null!;
+	public Guid MotionGlobalId { get; set; }
+	public MotionGlobal MotionGlobal { get; set; } = null!;
+	public IEnumerable<AccountMotion> Motions { get; set; } = null!;
+}

MyOffice.Data.Models/Motions/MotionCategory.cs

@@ -0,0 +1,12 @@
+namespace MyOffice.Data.Models.Motions;
+
+using Users;
+
+public class MotionCategory
+{
+	public Guid Id { get; set; }
+	public Guid UserId { get; set; }
+	public User User { get; set; } = null!;
+	public string Name { get; set; } = null!;
+	public IEnumerable<MotionAccount> Motions { get; set; } = null!;
+}

MyOffice.Data.Models/Motions/MotionGlobal.cs

@@ -0,0 +1,8 @@
+namespace MyOffice.Data.Models.Motions;
+
+public class MotionGlobal
+{
+	public Guid Id { get; set; }
+	public string Name { get; set; } = null!;
+	public IEnumerable<MotionAccount> Motions { get; set; } = null!;
+}

MyOffice.Data.Models/Users/User.cs

@@ -1,9 +1,16 @@
 namespace MyOffice.Data.Models.Users;
 
-using Account;
+using Accounts;
+using Currencies;
+using Motions;
 
 public class User
 {
+	public User()
+	{
+		CurrencyId = "USD";
+	}
+
 	public Guid Id { get; set; }
 	public string UserName { get; set; } = null!;
 	public string Email { get; set; } = null!;
@@ -15,5 +22,11 @@ public class User
 	public bool IsEmailConfirmed { get; set; }
 	public IEnumerable<UserExternal>? UserClaims { get; set; }
 
+	public string CurrencyId { get; set; }
+	public CurrencyGlobal? Currency { get; set; }
 	public IEnumerable<Currency>? Currencies { get; set; }
+	public IEnumerable<AccountAccess>? AccountAccess { get; set; }
+	public IEnumerable<AccountMotion>? AccountMotions { get; set; }
+	public IEnumerable<AccountCategory>? AccountCategories { get; set; }
+	public IEnumerable<MotionCategory>? MotionCategories { get; set; }
 }

MyOffice.Data.Repositories/Account/AccountAccountCategoryRepository.cs

@@ -0,0 +1,21 @@
+namespace MyOffice.Data.Repositories.Account;
+
+using Microsoft.EntityFrameworkCore;
+using Models.Accounts;
+
+public class AccountAccountCategoryRepository : AppRepository<AccountAccountCategory>, IAccountAccountCategoryRepository
+{
+	public List<AccountAccountCategory> Get(Guid userId, Guid accountId, Guid categoryId)
+	{
+		return _context.AccountAccountCategories
+			.Include(x => x.Account)
+			.Include(x => x.Category)
+			.Where(x => x.AccountId == accountId && x.CategoryId == categoryId && x.Category.UserId == userId)
+			.ToList();
+	}
+
+	public bool Remove(AccountAccountCategory accountAccountCategory)
+	{
+		return RemoveBase(accountAccountCategory) > 0;
+	}
+}

MyOffice.Data.Repositories/Account/AccountCategoryRepository.cs

@@ -0,0 +1,38 @@
+namespace MyOffice.Data.Repositories.Account;
+
+using Microsoft.EntityFrameworkCore;
+using Models.Accounts;
+using MyOffice.Data.Repositories;
+
+public class AccountCategoryRepository : AppRepository<AccountCategory>, IAccountCategoryRepository
+{
+	public List<AccountCategory> GetAll(Guid userId)
+	{
+		return _context.AccountCategories
+			.Include(x => x.Accounts)
+			.Where(x => x.UserId == userId)
+			.ToList();
+	}
+
+	public bool Add(AccountCategory accountCategory)
+	{
+		return AddBase(accountCategory) > 0;
+	}
+
+	public AccountCategory? Get(Guid userId, Guid id)
+	{
+		return _context.AccountCategories
+			.Include(x => x.Accounts)
+			.FirstOrDefault(x => x.Id == id && x.UserId == userId);
+	}
+
+	public bool Update(AccountCategory accountCategory)
+	{
+		return UpdateBase(accountCategory) > 0;
+	}
+
+	public bool Remove(AccountCategory accountCategory)
+	{
+		return RemoveBase(accountCategory) > 0;
+	}
+}

MyOffice.Data.Repositories/Account/AccountMotionRepository.cs

@@ -0,0 +1,11 @@
+namespace MyOffice.Data.Repositories.Account;
+
+using Models.Accounts;
+
+public class AccountMotionRepository : AppRepository<AccountMotion>, IAccountMotionRepository
+{
+	public bool Add(AccountMotion accountMotion)
+	{
+		return AddBase(accountMotion) > 0;
+	}
+}

MyOffice.Data.Repositories/Account/AccountRepository.cs

@@ -0,0 +1,75 @@
+namespace MyOffice.Data.Repositories.Account;
+
+using Microsoft.EntityFrameworkCore;
+using Models.Accounts;
+using MyOffice.Data.Repositories;
+
+public class AccountRepository : AppRepository<Account>, IAccountRepository
+{
+	public List<Account> GetAll(Guid userId)
+	{
+		return _context.Accounts!
+			.Include(x => x.CurrencyGlobal)
+			.Include(x => x.Categories)!
+			.ThenInclude(x => x.Category)
+			.Include(x => x.AccessRights)!
+			.ThenInclude(x => x.User)
+			.Where(x => x.AccessRights!.Any(a => a.UserId == userId))
+			.ToList();
+	}
+
+	public List<Account> GetByCategory(Guid userId, Guid categoryId)
+	{
+		return _context.Accounts!
+			.Include(x => x.CurrencyGlobal)
+			.Include(x => x.Categories)!
+			.ThenInclude(x => x.Category)
+			.Include(x => x.AccessRights)!
+			.ThenInclude(x => x.User)
+			.Where(x => x.Categories!.Any(c => c.CategoryId == categoryId) && x.AccessRights!.Any(a => a.UserId == userId))
+			.ToList();
+	}
+
+	public List<AccountDetailed> GetByCategoryDetailed(Guid userId, Guid categoryId)
+	{
+		return _context.Accounts!
+			.Include(x => x.CurrencyGlobal)
+			.Include(x => x.Categories)!
+			.ThenInclude(x => x.Category)
+			.Include(x => x.AccessRights)!
+			.ThenInclude(x => x.User)
+			.Where(x => x.Categories!.Any(c => c.CategoryId == categoryId) && x.AccessRights!.Any(a => a.UserId == userId))
+			.Select(x => new AccountDetailed
+			{
+				Account = x,
+				TotalPlus = x.Motions!.Sum(m => m.AmountPlus),
+				TotalMinus = x.Motions!.Sum(m => m.AmountPlus),
+			})
+			.ToList();
+	}
+
+	public bool Add(Account account)
+	{
+		return AddBase(account) > 0;
+	}
+
+	public Account? Get(Guid userId, Guid id)
+	{
+		return _context.Accounts!
+			.Include(x => x.Categories)!
+			.ThenInclude(x => x.Category)
+			.Include(x => x.AccessRights)!
+			.ThenInclude(x => x.User)
+			.FirstOrDefault(x => x.Id == id && x.AccessRights!.Any(r => r.UserId == userId));
+	}
+
+	public bool Update(Account account)
+	{
+		return UpdateBase(account) > 0;
+	}
+
+	public bool Remove(Account account)
+	{
+		return RemoveBase(account) > 0;
+	}
+}

MyOffice.Data.Repositories/Account/IAccountAccountCategoryRepository.cs

@@ -0,0 +1,9 @@
+namespace MyOffice.Data.Repositories.Account;
+
+using Models.Accounts;
+
+public interface IAccountAccountCategoryRepository
+{
+	List<AccountAccountCategory> Get(Guid userId, Guid accountId, Guid categoryId);
+	bool Remove(AccountAccountCategory accountAccountCategory);
+}

MyOffice.Data.Repositories/Account/IAccountCategoryRepository.cs

@@ -0,0 +1,12 @@
+namespace MyOffice.Data.Repositories.Account;
+
+using Models.Accounts;
+
+public interface IAccountCategoryRepository
+{
+	List<AccountCategory> GetAll(Guid userId);
+	bool Add(AccountCategory accountCategory);
+	AccountCategory? Get(Guid userId, Guid id);
+	bool Update(AccountCategory accountCategory);
+	bool Remove(AccountCategory accountCategory);
+}

MyOffice.Data.Repositories/Account/IAccountMotionRepository.cs

@@ -0,0 +1,8 @@
+namespace MyOffice.Data.Repositories.Account;
+
+using Models.Accounts;
+
+public interface IAccountMotionRepository
+{
+	bool Add(AccountMotion accountMotion);
+}

MyOffice.Data.Repositories/Account/IAccountyRepository.cs

@@ -0,0 +1,14 @@
+namespace MyOffice.Data.Repositories.Account;
+
+using Models.Accounts;
+
+public interface IAccountRepository
+{
+	List<Account> GetAll(Guid userId);
+	List<Account> GetByCategory(Guid userId, Guid categoryId);
+	List<AccountDetailed> GetByCategoryDetailed(Guid userId, Guid categoryId);
+	bool Add(Account account);
+	Account? Get(Guid userId, Guid id);
+	bool Update(Account account);
+	bool Remove(Account account);
+}

MyOffice.Data.Repositories/Currency/CurrencyGlobalRepository.cs

@@ -0,0 +1,11 @@
+namespace MyOffice.Data.Repositories.Currency;
+
+using Models.Currencies;
+
+public class CurrencyGlobalRepository : AppRepository<CurrencyGlobal>, ICurrencyGlobalRepository
+{
+	public List<CurrencyGlobal> GetAll()
+	{
+		return _context.CurrencyGlobals.ToList();
+	}
+}

MyOffice.Data.Repositories/Currency/CurrencyRateRepository.cs

@@ -0,0 +1,29 @@
+namespace MyOffice.Data.Repositories.Currency;
+
+using Models.Currencies;
+
+public class CurrencyRateRepository : AppRepository<CurrencyRate>, ICurrencyRateRepository
+{
+	public List<CurrencyRate> GetLastRates(Guid currencyId, int count = 1)
+	{
+		return _context.CurrencyRates
+			.Where(x => x.CurrencyId == currencyId)
+			.OrderByDescending(x => x.DateTime)
+			.ThenByDescending(x => x.Id)
+			.Take(count)
+			.ToList();
+	}
+
+	public bool AddRate(CurrencyRate currencyRate)
+	{
+		return this.AddBase(currencyRate) > 0;
+	}
+
+	public List<CurrencyRate> GetAtDate(Guid currencyId, DateTime date)
+	{
+		return _context.CurrencyRates
+			.Where(x => x.CurrencyId == currencyId && x.DateTime == date)
+			.ToList();
+
+	}
+}

MyOffice.Data.Repositories/Currency/CurrencyRepository.cs

@@ -0,0 +1,41 @@
+namespace MyOffice.Data.Repositories.Currency;
+
+using Microsoft.EntityFrameworkCore;
+using Models.Currencies;
+using MyOffice.Data.Repositories;
+
+public class CurrencyRepository : AppRepository<Currency>, ICurrencyRepository
+{
+	public List<Currency> GetAll(Guid userId)
+	{
+		return _context.Currencies
+			.Include(x => x.CurrencyGlobal)
+			.Where(x => x.UserId == userId)
+			.ToList();
+	}
+
+	public Currency? Get(Guid userId, Guid id)
+	{
+		return _context.Currencies.FirstOrDefault(x => x.Id == id && x.UserId == userId);
+	}
+
+	public Currency? GetByGlobalCurrency(Guid userId, string globalCurrencyId)
+	{
+		return _context.Currencies.FirstOrDefault(x => x.UserId == userId && x.CurrencyGlobalId == globalCurrencyId);
+	}
+
+	public bool Add(Currency currency)
+	{
+		return AddBase(currency) > 0;
+	}
+
+	public bool Update(Currency currency)
+	{
+		return UpdateBase(currency) > 0;
+	}
+
+	public bool Remove(Currency currency)
+	{
+		return RemoveBase(currency) > 0;
+	}
+}

MyOffice.Data.Repositories/Currency/ICurrencyGlobalRepository.cs

@@ -0,0 +1,8 @@
+namespace MyOffice.Data.Repositories.Currency;
+
+using Models.Currencies;
+
+public interface ICurrencyGlobalRepository
+{
+	List<CurrencyGlobal> GetAll();
+}

MyOffice.Data.Repositories/Currency/ICurrencyRateRepository.cs

@@ -0,0 +1,10 @@
+namespace MyOffice.Data.Repositories.Currency;
+
+using Models.Currencies;
+
+public interface ICurrencyRateRepository
+{
+	List<CurrencyRate> GetLastRates(Guid currencyId, int count = 1);
+	bool AddRate(CurrencyRate currencyRate);
+	List<CurrencyRate> GetAtDate(Guid currencyId, DateTime date);
+}

MyOffice.Data.Repositories/Currency/ICurrencyRepository.cs

@@ -0,0 +1,13 @@
+namespace MyOffice.Data.Repositories.Currency;
+
+using Models.Currencies;
+
+public interface ICurrencyRepository
+{
+	List<Currency> GetAll(Guid userId);
+	Currency? Get(Guid userId, Guid id);
+	Currency? GetByGlobalCurrency(Guid userId, string globalCurrencyId);
+	bool Add(Currency currency);
+	bool Update(Currency currency);
+	bool Remove(Currency currency);
+}

MyOffice.Data.Repositories/Motion/IMotionCategoryRepository.cs

@@ -0,0 +1,12 @@
+namespace MyOffice.Data.Repositories.Motion;
+
+using Models.Motions;
+
+public interface IMotionCategoryRepository
+{
+	List<MotionCategory> GetAll(Guid userId);
+	bool Add(MotionCategory accountCategory);
+	MotionCategory? Get(Guid userId, Guid id);
+	bool Update(MotionCategory accountCategory);
+	bool Remove(MotionCategory accountCategory);
+}

MyOffice.Data.Repositories/Motion/IMotionGlobalRepository.cs

@@ -0,0 +1,10 @@
+namespace MyOffice.Data.Repositories.Motion;
+
+using Models.Motions;
+
+public interface IMotionGlobalRepository
+{
+	MotionGlobal? Get(Guid id);
+	MotionGlobal? GetByName(string name);
+	bool Add(MotionGlobal motionGlobal);
+}

MyOffice.Data.Repositories/Motion/IMotionsRepository.cs

@@ -0,0 +1,13 @@
+namespace MyOffice.Data.Repositories.Motion;
+
+using Models.Motions;
+
+public interface IMotionRepository
+{
+	List<MotionAccount> GetAll(Guid userId);
+	List<MotionAccount> GetByCategory(Guid userId, Guid categoryId);
+
+	MotionAccount? GetByGlobal(Guid userId, Guid globalMotionId);
+	bool Add(MotionAccount motionAccount);
+	bool Update(MotionAccount motionAccount);
+}

MyOffice.Data.Repositories/Motion/MotionCategoryRepository.cs

@@ -0,0 +1,37 @@
+namespace MyOffice.Data.Repositories.Motion;
+
+using Microsoft.EntityFrameworkCore;
+using Models.Motions;
+
+public class MotionCategoryRepository : AppRepository<MotionCategory>, IMotionCategoryRepository
+{
+	public List<MotionCategory> GetAll(Guid userId)
+	{
+		return _context.MotionCategories
+			.Include(x => x.Motions)
+			.Where(x => x.UserId == userId)
+			.ToList();
+	}
+
+	public bool Add(MotionCategory motionCategory)
+	{
+		return AddBase(motionCategory) > 0;
+	}
+
+	public MotionCategory? Get(Guid userId, Guid id)
+	{
+		return _context.MotionCategories
+			.Include(x => x.Motions)
+			.FirstOrDefault(x => x.Id == id && x.UserId == userId);
+	}
+
+	public bool Update(MotionCategory motionCategory)
+	{
+		return UpdateBase(motionCategory) > 0;
+	}
+
+	public bool Remove(MotionCategory motionCategory)
+	{
+		return RemoveBase(motionCategory) > 0;
+	}
+}

MyOffice.Data.Repositories/Motion/MotionGlobalRepository.cs

@@ -0,0 +1,21 @@
+namespace MyOffice.Data.Repositories.Motion;
+
+using Models.Motions;
+
+public class MotionGlobalRepository : AppRepository<MotionGlobal>, IMotionGlobalRepository
+{
+	public MotionGlobal? Get(Guid id)
+	{
+		return _context.GlobalMotions.FirstOrDefault(x => x.Id == id);
+	}
+
+	public MotionGlobal? GetByName(string name)
+	{
+		return _context.GlobalMotions.FirstOrDefault(x => x.Name == name);
+	}
+
+	public bool Add(MotionGlobal motionGlobal)
+	{
+		return AddBase(motionGlobal) > 0;
+	}
+}

MyOffice.Data.Repositories/Motion/MotionRepository.cs

@@ -0,0 +1,46 @@
+namespace MyOffice.Data.Repositories.Motion;
+
+using Microsoft.EntityFrameworkCore;
+using Models.Motions;
+
+public class MotionRepository : AppRepository<MotionAccount>, IMotionRepository
+{
+	public List<MotionAccount> GetAll(Guid userId)
+	{
+		return _context.Motions
+			.Include(x => x.Motions)
+			.Include(x => x.Category)
+			.Include(x => x.MotionGlobal)
+			.Where(x => x.Category.UserId == userId)
+			.ToList();
+	}
+
+	public List<MotionAccount> GetByCategory(Guid userId, Guid categoryId)
+	{
+		return _context.Motions
+			.Include(x => x.Motions)
+			.Include(x => x.Category)
+			.Include(x => x.MotionGlobal)
+			.Where(x => x.Category.UserId == userId && x.CategoryId == categoryId)
+			.ToList();
+	}
+
+	public MotionAccount? GetByGlobal(Guid userId, Guid globalMotionId)
+	{
+		return _context.Motions
+			.Include(x => x.Motions)
+			.Include(x => x.Category)
+			.Include(x => x.MotionGlobal)
+			.FirstOrDefault(x => x.Category.UserId == userId && x.MotionGlobalId == globalMotionId);
+	}
+
+	public bool Update(MotionAccount motionAccount)
+	{
+		return base.UpdateBase(motionAccount) > 0;
+	}
+
+	public bool Add(MotionAccount motionAccount)
+	{
+		return base.AddBase(motionAccount) > 0;
+	}
+}

MyOffice.Data.Repositories/RepositoryBase.cs

@@ -39,30 +39,34 @@ public class RepositoryBase<TEntity> where TEntity : class
 	}
 
 
-	protected async Task<TEntity?> GetAsync(Guid id)
+	protected async Task<TEntity?> GetBaseAsync(Guid id)
 	{
 		return await _context.Set<TEntity>().FindAsync(id);
 	}
 
-	protected async Task<int> AddAsync(TEntity entity)
+	protected async Task<int> AddBaseAsync(TEntity entity)
 	{
-		await _context.Set<TEntity>().AddAsync(entity);
+		//await _context.Set<TEntity>().AddAsync(entity);
+		await _context.AddAsync(entity);
 		return await SaveChangesAsync();
 	}
 
-	protected int Add(TEntity entity)
+	protected int AddBase(TEntity entity)
 	{
-		_context.Set<TEntity>().Add(entity);
+		//_context.Set<TEntity>().Add(entity);
+		_context.Add(entity);
 		return SaveChanges();
 	}
 
-	protected int Remove(TEntity entity)
+	protected int RemoveBase(TEntity entity)
 	{
 		_context.Set<TEntity>().Remove(entity);
+		_context.Entry(entity).State = EntityState.Deleted;
+
 		return SaveChanges();
 	}
 
-	protected async Task<int> UpdateAsync(TEntity entity)
+	protected async Task<int> UpdateBaseAsync(TEntity entity)
 	{
 		_context.Attach(entity);
 		_context.Entry(entity).State = EntityState.Modified;
@@ -70,9 +74,11 @@ public class RepositoryBase<TEntity> where TEntity : class
 		return await SaveChangesAsync();
 	}
 
-	protected int Update(TEntity entity)
+	protected int UpdateBase(TEntity entity)
 	{
 		_context.Attach(entity);
+		_context.Entry(entity).State = EntityState.Modified;
+
 		return SaveChanges();
 	}
 }

MyOffice.Data.Repositories/Users/UserExternalRepository.cs

@@ -8,12 +8,12 @@ public class UserExternalRepository : AppRepository<UserExternal>, IUserExternal
 {
 	public async Task<int> AddUserExternalAsync(UserExternal userExternal)
 	{
-		return await AddAsync(userExternal);
+		return await AddBaseAsync(userExternal);
 	}
 
 	public int AddUserExternal(UserExternal userExternal)
 	{
-		return Add(userExternal);
+		return AddBase(userExternal);
 	}
 
 	public async Task<int> AddUserExternalsAsync(IEnumerable<UserExternal> claims)
@@ -93,6 +93,6 @@ public class UserExternalRepository : AppRepository<UserExternal>, IUserExternal
 
 	public void RemoveUserExternal(UserExternal userExternal)
 	{
-		Remove(userExternal);
+		RemoveBase(userExternal);
 	}
 }

MyOffice.Data.Repositories/Users/UserRepository.cs

@@ -8,7 +8,7 @@ public class UserRepository : AppRepository<User>, IUserRepository
 {
 	public async Task<User?> GetUserAsync(Guid id)
 	{
-		return await GetAsync(id);
+		return await GetBaseAsync(id);
 	}
 
 	public async Task<User?> GetByUserUserNameAsync(string userName)
@@ -23,11 +23,11 @@ public class UserRepository : AppRepository<User>, IUserRepository
 
 	public async Task<int> AddUserAsync(User user)
 	{
-		return await AddAsync(user);
+		return await AddBaseAsync(user);
 	}
 
 	public async Task<int> UpdateUserAsync(User user)
 	{
-		return await UpdateAsync(user);
+		return await UpdateBaseAsync(user);
 	}
 }

MyOffice.DbContext/AppDbContext.cs

@@ -1,6 +1,8 @@
 namespace MyOffice.DbContext;
 
-using Data.Models.Account;
+using Data.Models.Accounts;
+using Data.Models.Currencies;
+using Data.Models.Motions;
 using Microsoft.EntityFrameworkCore;
 using Data.Models.Users;
 
@@ -29,6 +31,19 @@ public class AppDbContext : DbContext
 	public DbSet<User> Users { get; set; } = null!;
 	public DbSet<UserExternal> UserClaims { get; set; } = null!;
 
+	public DbSet<CurrencyGlobal> CurrencyGlobals { get; set; } = null!;
+	public DbSet<Currency> Currencies { get; set; } = null!;
+	public DbSet<CurrencyRate> CurrencyRates { get; set; } = null!;
+	public DbSet<AccountCategory> AccountCategories { get; set; } = null!;
+	public DbSet<Account> Accounts { get; set; } = null!;
+	public DbSet<AccountAccountCategory> AccountAccountCategories { get; set; } = null!;
+	public DbSet<AccountAccess> AccountAccesses { get; set; } = null!;
+
+	public DbSet<MotionGlobal> GlobalMotions { get; set; } = null!;
+	public DbSet<MotionCategory> MotionCategories { get; set; } = null!;
+	public DbSet<MotionAccount> Motions { get; set; } = null!;
+	//public DbSet<AccountMotion> AccountMotions { get; set; } = null!;
+
 	protected override void OnModelCreating(ModelBuilder modelBuilder)
 	{
 		var noCaseCollation = _noCaseCollation[_provider];
@@ -59,12 +74,22 @@ public class AppDbContext : DbContext
 			.WithMany(x => x.UserClaims)
 			.HasForeignKey(x => x.UserId);
 
+		UserCreating(modelBuilder);
 		CurrencyCreating(modelBuilder);
 		AccountCreating(modelBuilder);
+		MotionsCreating(modelBuilder);
 
 		base.OnModelCreating(modelBuilder);
 	}
 
+	private void UserCreating(ModelBuilder modelBuilder)
+	{
+		modelBuilder.Entity<User>()
+			.HasOne(x => x.Currency)
+			.WithMany()
+			.HasForeignKey(x => x.CurrencyId);
+	}
+
 	private void CurrencyCreating(ModelBuilder modelBuilder)
 	{
 		modelBuilder.Entity<CurrencyGlobal>()
@@ -103,6 +128,12 @@ public class AppDbContext : DbContext
 		modelBuilder.Entity<AccountMotion>()
 			.HasKey(x => x.Id);
 
+		modelBuilder.Entity<AccountCategory>()
+			.HasKey(x => x.Id);
+
+		modelBuilder.Entity<AccountAccountCategory>()
+			.HasKey(x => x.Id);
+
 		modelBuilder.Entity<Account>()
 			.HasOne(x => x.CurrencyGlobal)
 			.WithMany(x => x.Accounts)
@@ -115,7 +146,64 @@ public class AppDbContext : DbContext
 
 		modelBuilder.Entity<AccountAccess>()
 			.HasOne(x => x.User)
-			.WithMany(x => x.AccessRights)
+			.WithMany(x => x.AccountAccess)
+			.HasForeignKey(x => x.UserId);
+
+		modelBuilder.Entity<AccountMotion>()
+			.HasOne(x => x.Account)
+			.WithMany(x => x.Motions)
 			.HasForeignKey(x => x.AccountId);
+
+		modelBuilder.Entity<AccountCategory>()
+			.HasOne(x => x.User)
+			.WithMany(x => x.AccountCategories)
+			.HasForeignKey(x => x.UserId);
+
+		modelBuilder.Entity<AccountAccountCategory>()
+			.HasOne(x => x.Account)
+			.WithMany(x => x.Categories)
+			.HasForeignKey(x => x.AccountId);
+
+		modelBuilder.Entity<AccountAccountCategory>()
+			.HasOne(x => x.Category)
+			.WithMany(x => x.Accounts)
+			.HasForeignKey(x => x.CategoryId);
+	}
+
+	private void MotionsCreating(ModelBuilder modelBuilder)
+	{
+		modelBuilder.Entity<MotionGlobal>()
+			.HasKey(x => x.Id);
+		modelBuilder.Entity<MotionCategory>()
+			.HasKey(x => x.Id);
+		modelBuilder.Entity<MotionAccount>()
+			.HasKey(x => x.Id);
+		modelBuilder.Entity<AccountMotion>()
+			.HasKey(x => x.Id);
+
+		modelBuilder.Entity<MotionCategory>()
+			.HasOne(x => x.User)
+			.WithMany(x => x.MotionCategories)
+			.HasForeignKey(x => x.UserId);
+
+		modelBuilder.Entity<MotionAccount>()
+			.HasOne(x => x.Category)
+			.WithMany(x => x.Motions)
+			.HasForeignKey(x => x.CategoryId);
+
+		modelBuilder.Entity<MotionAccount>()
+			.HasOne(x => x.MotionGlobal)
+			.WithMany(x => x.Motions)
+			.HasForeignKey(x => x.MotionGlobalId);
+
+		/*modelBuilder.Entity<AccountMotion>()
+			.HasOne(x => x.Motion)
+			.WithMany(x => x.Motions)
+			.HasForeignKey(x => x.MotionId);
+
+		modelBuilder.Entity<AccountMotion>()
+			.HasOne(x => x.Account)
+			.WithMany(x => x.Motions)
+			.HasForeignKey(x => x.AccountId);*/
 	}
 }

MyOffice.DbContext/RepositoryInitializer.cs

@@ -1,5 +1,6 @@
 namespace MyOffice.DbContext;
 
+using Data.Models.Currencies;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -17,10 +18,34 @@ public class RepositoryInitializer
 
 		var db = AppDbContextFactory.Instance.CreateDbContext();
 		db.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
-		//db.Database.EnsureCreated();
 		db.Database.Migrate();
+		Prefill(db);
 	}
 
 	public static ConnectionConfiguration ConnectionString { get; internal set; } = null!;
 	public static IServiceCollection Services { get; internal set; } = null!;
+
+	private static void Prefill(AppDbContext dbContext)
+	{
+		// CurrencyGlobals
+		var predefinedCurrencyGlobals = new List<CurrencyGlobal>()
+		{
+			new() { Id = "UAH", DefaultQuantity = 1, Symbol = "₴", Name = "Ukrainian hryvnias" },
+			new() { Id = "USD", DefaultQuantity = 1, Symbol = "$", Name = "US Dollar" },
+			new() { Id = "EUR", DefaultQuantity = 1, Symbol = "€", Name = "Euros" },
+			new() { Id = "GBP", DefaultQuantity = 1, Symbol = "£", Name = "British pounds sterling" },
+			new() { Id = "RUB", DefaultQuantity = 10, Symbol = "₽", Name = "Russia Ruble" },
+		};
+
+		var currencyGlobals = dbContext.CurrencyGlobals.ToList();
+		foreach (var predefined in predefinedCurrencyGlobals)
+		{
+			if (currencyGlobals.FirstOrDefault(x => x.Id == predefined.Id) == null)
+			{
+				dbContext.CurrencyGlobals.Add(predefined);
+			}
+		}
+
+		dbContext.SaveChanges();
+	}
 }

MyOffice.Migration.Postgres/Migrations/20230429063332_Host.Designer.cs

@@ -0,0 +1,386 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230429063332_Host")]
+    partial class Host
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountIn")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountOut")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230429063332_Host.cs

@@ -0,0 +1,217 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class Host : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "CurrencyGlobals",
+                columns: table => new
+                {
+                    Id = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false),
+                    ShortName = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_CurrencyGlobals", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Accounts",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    CurrencyGlobalId = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Accounts", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Accounts_CurrencyGlobals_CurrencyGlobalId",
+                        column: x => x.CurrencyGlobalId,
+                        principalTable: "CurrencyGlobals",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Currencies",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    CurrencyGlobalId = table.Column<string>(type: "text", nullable: false),
+                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false),
+                    ShortName = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Currencies", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Currencies_CurrencyGlobals_CurrencyGlobalId",
+                        column: x => x.CurrencyGlobalId,
+                        principalTable: "CurrencyGlobals",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Currencies_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AccountAccesses",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    AccountId = table.Column<Guid>(type: "uuid", nullable: false),
+                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
+                    IsAllowRead = table.Column<bool>(type: "boolean", nullable: false),
+                    IsAllowWrite = table.Column<bool>(type: "boolean", nullable: false),
+                    IsAllowManage = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AccountAccesses", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_AccountAccesses_Accounts_AccountId",
+                        column: x => x.AccountId,
+                        principalTable: "Accounts",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_AccountAccesses_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AccountMotions",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    CreatedOn = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    DateTime = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    AccountId = table.Column<Guid>(type: "uuid", nullable: false),
+                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
+                    AmountIn = table.Column<decimal>(type: "numeric", nullable: false),
+                    AmountOut = table.Column<decimal>(type: "numeric", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AccountMotions", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_AccountMotions_Accounts_AccountId",
+                        column: x => x.AccountId,
+                        principalTable: "Accounts",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_AccountMotions_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "CurrencyRates",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    CurrencyId = table.Column<Guid>(type: "uuid", nullable: false),
+                    DateTime = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    Rate = table.Column<decimal>(type: "numeric", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_CurrencyRates", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_CurrencyRates_Currencies_CurrencyId",
+                        column: x => x.CurrencyId,
+                        principalTable: "Currencies",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AccountAccesses_AccountId",
+                table: "AccountAccesses",
+                column: "AccountId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AccountAccesses_UserId",
+                table: "AccountAccesses",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AccountMotions_AccountId",
+                table: "AccountMotions",
+                column: "AccountId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AccountMotions_UserId",
+                table: "AccountMotions",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Accounts_CurrencyGlobalId",
+                table: "Accounts",
+                column: "CurrencyGlobalId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Currencies_CurrencyGlobalId",
+                table: "Currencies",
+                column: "CurrencyGlobalId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Currencies_UserId",
+                table: "Currencies",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CurrencyRates_CurrencyId",
+                table: "CurrencyRates",
+                column: "CurrencyId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AccountAccesses");
+
+            migrationBuilder.DropTable(
+                name: "AccountMotions");
+
+            migrationBuilder.DropTable(
+                name: "CurrencyRates");
+
+            migrationBuilder.DropTable(
+                name: "Accounts");
+
+            migrationBuilder.DropTable(
+                name: "Currencies");
+
+            migrationBuilder.DropTable(
+                name: "CurrencyGlobals");
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230429090658_user_currency.Designer.cs

@@ -0,0 +1,407 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230429090658_user_currency")]
+    partial class usercurrency
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountIn")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountOut")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230429090658_user_currency.cs

@@ -0,0 +1,61 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class usercurrency : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "CurrencyId",
+                table: "Users",
+                type: "text",
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.AddColumn<string>(
+                name: "Symbol",
+                table: "CurrencyGlobals",
+                type: "text",
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Users_CurrencyId",
+                table: "Users",
+                column: "CurrencyId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Users_CurrencyGlobals_CurrencyId",
+                table: "Users",
+                column: "CurrencyId",
+                principalTable: "CurrencyGlobals",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Users_CurrencyGlobals_CurrencyId",
+                table: "Users");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Users_CurrencyId",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "CurrencyId",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "Symbol",
+                table: "CurrencyGlobals");
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230429092104_currency_shortname.Designer.cs

@@ -0,0 +1,403 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230429092104_currency_shortname")]
+    partial class currencyshortname
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountIn")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountOut")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230429092104_currency_shortname.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class currencyshortname : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ShortName",
+                table: "Currencies");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "ShortName",
+                table: "Currencies",
+                type: "text",
+                nullable: false,
+                defaultValue: "");
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230429092950_gcurrency_shortname.Designer.cs

@@ -0,0 +1,403 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230429092950_gcurrency_shortname")]
+    partial class gcurrencyshortname
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountIn")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountOut")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Account.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Account.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230429092950_gcurrency_shortname.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class gcurrencyshortname : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ShortName",
+                table: "CurrencyGlobals");
+
+            migrationBuilder.AddColumn<string>(
+                name: "ShortName",
+                table: "Currencies",
+                type: "text",
+                nullable: false,
+                defaultValue: "");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ShortName",
+                table: "Currencies");
+
+            migrationBuilder.AddColumn<string>(
+                name: "ShortName",
+                table: "CurrencyGlobals",
+                type: "text",
+                nullable: false,
+                defaultValue: "");
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230430103617_account_category.Designer.cs

@@ -0,0 +1,467 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230430103617_account_category")]
+    partial class accountcategory
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("AccountAccountCategory");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AccountCategory");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountIn")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountOut")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.AccountCategory", "Category")
+                        .WithMany("Accounts")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Categories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Categories");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230430103617_account_category.cs

@@ -0,0 +1,74 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class accountcategory : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "AccountCategory",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AccountCategory", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "AccountAccountCategory",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    AccountId = table.Column<Guid>(type: "uuid", nullable: false),
+                    CategoryId = table.Column<Guid>(type: "uuid", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AccountAccountCategory", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_AccountAccountCategory_AccountCategory_AccountId",
+                        column: x => x.AccountId,
+                        principalTable: "AccountCategory",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_AccountAccountCategory_Accounts_CategoryId",
+                        column: x => x.CategoryId,
+                        principalTable: "Accounts",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AccountAccountCategory_AccountId",
+                table: "AccountAccountCategory",
+                column: "AccountId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AccountAccountCategory_CategoryId",
+                table: "AccountAccountCategory",
+                column: "CategoryId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AccountAccountCategory");
+
+            migrationBuilder.DropTable(
+                name: "AccountCategory");
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230601100601_CurrencyQuantity.Designer.cs

@@ -0,0 +1,473 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230601100601_CurrencyQuantity")]
+    partial class CurrencyQuantity
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("AccountAccountCategory");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AccountCategory");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountIn")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountOut")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("DefaultQuantity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Quantity")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.AccountCategory", "Category")
+                        .WithMany("Accounts")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Categories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Categories");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230601100601_CurrencyQuantity.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class CurrencyQuantity : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "Quantity",
+                table: "CurrencyRates",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "DefaultQuantity",
+                table: "Currencies",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Quantity",
+                table: "CurrencyRates");
+
+            migrationBuilder.DropColumn(
+                name: "DefaultQuantity",
+                table: "Currencies");
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230601100833_CurrencyQuantity2.Designer.cs

@@ -0,0 +1,473 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230601100833_CurrencyQuantity2")]
+    partial class CurrencyQuantity2
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("AccountAccountCategory");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AccountCategory");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountIn")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountOut")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("DefaultQuantity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Quantity")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.AccountCategory", "Category")
+                        .WithMany("Accounts")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Categories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Categories");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230601100833_CurrencyQuantity2.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class CurrencyQuantity2 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "DefaultQuantity",
+                table: "Currencies");
+
+            migrationBuilder.AddColumn<int>(
+                name: "DefaultQuantity",
+                table: "CurrencyGlobals",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "DefaultQuantity",
+                table: "CurrencyGlobals");
+
+            migrationBuilder.AddColumn<int>(
+                name: "DefaultQuantity",
+                table: "Currencies",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230601121013_AccountCategories.Designer.cs

@@ -0,0 +1,491 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230601121013_AccountCategories")]
+    partial class AccountCategories
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("AccountAccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountIn")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountOut")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("DefaultQuantity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Quantity")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.AccountCategory", "Category")
+                        .WithMany("Accounts")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Categories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Categories");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountCategories");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230601121013_AccountCategories.cs

@@ -0,0 +1,171 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class AccountCategories : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountAccountCategory_AccountCategory_AccountId",
+                table: "AccountAccountCategory");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountAccountCategory_Accounts_CategoryId",
+                table: "AccountAccountCategory");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_AccountCategory",
+                table: "AccountCategory");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_AccountAccountCategory",
+                table: "AccountAccountCategory");
+
+            migrationBuilder.RenameTable(
+                name: "AccountCategory",
+                newName: "AccountCategories");
+
+            migrationBuilder.RenameTable(
+                name: "AccountAccountCategory",
+                newName: "AccountAccountCategories");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_AccountAccountCategory_CategoryId",
+                table: "AccountAccountCategories",
+                newName: "IX_AccountAccountCategories_CategoryId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_AccountAccountCategory_AccountId",
+                table: "AccountAccountCategories",
+                newName: "IX_AccountAccountCategories_AccountId");
+
+            migrationBuilder.AddColumn<Guid>(
+                name: "UserId",
+                table: "AccountCategories",
+                type: "uuid",
+                nullable: false,
+                defaultValue: new Guid("00000000-0000-0000-0000-000000000000"));
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_AccountCategories",
+                table: "AccountCategories",
+                column: "Id");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_AccountAccountCategories",
+                table: "AccountAccountCategories",
+                column: "Id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AccountCategories_UserId",
+                table: "AccountCategories",
+                column: "UserId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountAccountCategories_AccountCategories_AccountId",
+                table: "AccountAccountCategories",
+                column: "AccountId",
+                principalTable: "AccountCategories",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountAccountCategories_Accounts_CategoryId",
+                table: "AccountAccountCategories",
+                column: "CategoryId",
+                principalTable: "Accounts",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountCategories_Users_UserId",
+                table: "AccountCategories",
+                column: "UserId",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountAccountCategories_AccountCategories_AccountId",
+                table: "AccountAccountCategories");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountAccountCategories_Accounts_CategoryId",
+                table: "AccountAccountCategories");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountCategories_Users_UserId",
+                table: "AccountCategories");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_AccountCategories",
+                table: "AccountCategories");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AccountCategories_UserId",
+                table: "AccountCategories");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_AccountAccountCategories",
+                table: "AccountAccountCategories");
+
+            migrationBuilder.DropColumn(
+                name: "UserId",
+                table: "AccountCategories");
+
+            migrationBuilder.RenameTable(
+                name: "AccountCategories",
+                newName: "AccountCategory");
+
+            migrationBuilder.RenameTable(
+                name: "AccountAccountCategories",
+                newName: "AccountAccountCategory");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_AccountAccountCategories_CategoryId",
+                table: "AccountAccountCategory",
+                newName: "IX_AccountAccountCategory_CategoryId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_AccountAccountCategories_AccountId",
+                table: "AccountAccountCategory",
+                newName: "IX_AccountAccountCategory_AccountId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_AccountCategory",
+                table: "AccountCategory",
+                column: "Id");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_AccountAccountCategory",
+                table: "AccountAccountCategory",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountAccountCategory_AccountCategory_AccountId",
+                table: "AccountAccountCategory",
+                column: "AccountId",
+                principalTable: "AccountCategory",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountAccountCategory_Accounts_CategoryId",
+                table: "AccountAccountCategory",
+                column: "CategoryId",
+                principalTable: "Accounts",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230609062452_AccountCategoriesFix.Designer.cs

@@ -0,0 +1,491 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230609062452_AccountCategoriesFix")]
+    partial class AccountCategoriesFix
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("AccountAccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountIn")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountOut")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("DefaultQuantity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Quantity")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Categories")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Accounts.AccountCategory", "Category")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currency.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Categories");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currency.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountCategories");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230609062452_AccountCategoriesFix.cs

@@ -0,0 +1,66 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class AccountCategoriesFix : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountAccountCategories_AccountCategories_AccountId",
+                table: "AccountAccountCategories");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountAccountCategories_Accounts_CategoryId",
+                table: "AccountAccountCategories");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountAccountCategories_AccountCategories_CategoryId",
+                table: "AccountAccountCategories",
+                column: "CategoryId",
+                principalTable: "AccountCategories",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountAccountCategories_Accounts_AccountId",
+                table: "AccountAccountCategories",
+                column: "AccountId",
+                principalTable: "Accounts",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountAccountCategories_AccountCategories_CategoryId",
+                table: "AccountAccountCategories");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountAccountCategories_Accounts_AccountId",
+                table: "AccountAccountCategories");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountAccountCategories_AccountCategories_AccountId",
+                table: "AccountAccountCategories",
+                column: "AccountId",
+                principalTable: "AccountCategories",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountAccountCategories_Accounts_CategoryId",
+                table: "AccountAccountCategories",
+                column: "CategoryId",
+                principalTable: "Accounts",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230611145152_Motion.Designer.cs

@@ -0,0 +1,606 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230611145152_Motion")]
+    partial class Motion
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("AccountAccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountMinus")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountPlus")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MotionId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("MotionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("DefaultQuantity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Quantity")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("MotionGlobalId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("MotionGlobalId");
+
+                    b.ToTable("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("MotionCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionGlobal", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GlobalMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Categories")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Accounts.AccountCategory", "Category")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionAccount", "Motion")
+                        .WithMany("Motions")
+                        .HasForeignKey("MotionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", null)
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Motion");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionCategory", "Category")
+                        .WithMany("Motions")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionGlobal", "MotionGlobal")
+                        .WithMany("Motions")
+                        .HasForeignKey("MotionGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+
+                    b.Navigation("MotionGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("MotionCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Categories");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionGlobal", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountCategories");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("MotionCategories");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230611145152_Motion.cs

@@ -0,0 +1,213 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class Motion : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountMotions_Users_UserId",
+                table: "AccountMotions");
+
+            migrationBuilder.RenameColumn(
+                name: "AmountOut",
+                table: "AccountMotions",
+                newName: "AmountPlus");
+
+            migrationBuilder.RenameColumn(
+                name: "AmountIn",
+                table: "AccountMotions",
+                newName: "AmountMinus");
+
+            migrationBuilder.AlterColumn<Guid>(
+                name: "UserId",
+                table: "AccountMotions",
+                type: "uuid",
+                nullable: true,
+                oldClrType: typeof(Guid),
+                oldType: "uuid");
+
+            migrationBuilder.AddColumn<string>(
+                name: "Description",
+                table: "AccountMotions",
+                type: "text",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "MotionId",
+                table: "AccountMotions",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.CreateTable(
+                name: "GlobalMotions",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_GlobalMotions", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MotionCategories",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MotionCategories", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_MotionCategories_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Motions",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    CategoryId = table.Column<Guid>(type: "uuid", nullable: false),
+                    MotionGlobalId = table.Column<Guid>(type: "uuid", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Motions", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Motions_GlobalMotions_MotionGlobalId",
+                        column: x => x.MotionGlobalId,
+                        principalTable: "GlobalMotions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Motions_MotionCategories_CategoryId",
+                        column: x => x.CategoryId,
+                        principalTable: "MotionCategories",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AccountMotions_MotionId",
+                table: "AccountMotions",
+                column: "MotionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MotionCategories_UserId",
+                table: "MotionCategories",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Motions_CategoryId",
+                table: "Motions",
+                column: "CategoryId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Motions_MotionGlobalId",
+                table: "Motions",
+                column: "MotionGlobalId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountMotions_Motions_MotionId",
+                table: "AccountMotions",
+                column: "MotionId",
+                principalTable: "Motions",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountMotions_Users_UserId",
+                table: "AccountMotions",
+                column: "UserId",
+                principalTable: "Users",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountMotions_Motions_MotionId",
+                table: "AccountMotions");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_AccountMotions_Users_UserId",
+                table: "AccountMotions");
+
+            migrationBuilder.DropTable(
+                name: "Motions");
+
+            migrationBuilder.DropTable(
+                name: "GlobalMotions");
+
+            migrationBuilder.DropTable(
+                name: "MotionCategories");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AccountMotions_MotionId",
+                table: "AccountMotions");
+
+            migrationBuilder.DropColumn(
+                name: "Description",
+                table: "AccountMotions");
+
+            migrationBuilder.DropColumn(
+                name: "MotionId",
+                table: "AccountMotions");
+
+            migrationBuilder.RenameColumn(
+                name: "AmountPlus",
+                table: "AccountMotions",
+                newName: "AmountOut");
+
+            migrationBuilder.RenameColumn(
+                name: "AmountMinus",
+                table: "AccountMotions",
+                newName: "AmountIn");
+
+            migrationBuilder.AlterColumn<Guid>(
+                name: "UserId",
+                table: "AccountMotions",
+                type: "uuid",
+                nullable: false,
+                defaultValue: new Guid("00000000-0000-0000-0000-000000000000"),
+                oldClrType: typeof(Guid),
+                oldType: "uuid",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<long>(
+                name: "Id",
+                table: "AccountMotions",
+                type: "bigint",
+                nullable: false,
+                oldClrType: typeof(Guid),
+                oldType: "uuid")
+                .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AccountMotions_Users_UserId",
+                table: "AccountMotions",
+                column: "UserId",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230614175616_MotionCategoryFix.Designer.cs

@@ -0,0 +1,609 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230614175616_MotionCategoryFix")]
+    partial class MotionCategoryFix
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("AccountAccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountMinus")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountPlus")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MotionId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("MotionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("DefaultQuantity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Quantity")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("MotionGlobalId")
+                        .IsRequired()
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("MotionGlobalId");
+
+                    b.ToTable("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("MotionCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionGlobal", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GlobalMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Categories")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Accounts.AccountCategory", "Category")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionAccount", "Motion")
+                        .WithMany("Motions")
+                        .HasForeignKey("MotionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", null)
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Motion");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionCategory", "Category")
+                        .WithMany("Motions")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionGlobal", "MotionGlobal")
+                        .WithMany("Motions")
+                        .HasForeignKey("MotionGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+
+                    b.Navigation("MotionGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("MotionCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Categories");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionGlobal", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountCategories");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("MotionCategories");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230614175616_MotionCategoryFix.cs

@@ -0,0 +1,38 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class MotionCategoryFix : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            /*migrationBuilder.AlterColumn<long>(
+                name: "Id",
+                table: "AccountMotions",
+                type: "bigint",
+                nullable: false,
+                oldClrType: typeof(Guid),
+                oldType: "uuid")
+                .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);*/
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            /*migrationBuilder.AlterColumn<Guid>(
+                name: "Id",
+                table: "AccountMotions",
+                type: "uuid",
+                nullable: false,
+                oldClrType: typeof(long),
+                oldType: "bigint")
+                .OldAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);*/
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230614181358_MotionCategoryFix2.Designer.cs

@@ -0,0 +1,606 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230614181358_MotionCategoryFix2")]
+    partial class MotionCategoryFix2
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("AccountAccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountMinus")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountPlus")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MotionId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("MotionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("DefaultQuantity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Quantity")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("MotionGlobalId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("MotionGlobalId");
+
+                    b.ToTable("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("MotionCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionGlobal", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GlobalMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Categories")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Accounts.AccountCategory", "Category")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionAccount", "Motion")
+                        .WithMany("Motions")
+                        .HasForeignKey("MotionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", null)
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Motion");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionCategory", "Category")
+                        .WithMany("Motions")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionGlobal", "MotionGlobal")
+                        .WithMany("Motions")
+                        .HasForeignKey("MotionGlobalId");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("MotionGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("MotionCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Categories");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionGlobal", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountCategories");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("MotionCategories");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230614181358_MotionCategoryFix2.cs

@@ -0,0 +1,60 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class MotionCategoryFix2 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Motions_GlobalMotions_MotionGlobalId",
+                table: "Motions");
+
+            migrationBuilder.AlterColumn<Guid>(
+                name: "MotionGlobalId",
+                table: "Motions",
+                type: "uuid",
+                nullable: true,
+                oldClrType: typeof(Guid),
+                oldType: "uuid");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Motions_GlobalMotions_MotionGlobalId",
+                table: "Motions",
+                column: "MotionGlobalId",
+                principalTable: "GlobalMotions",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Motions_GlobalMotions_MotionGlobalId",
+                table: "Motions");
+
+            migrationBuilder.AlterColumn<Guid>(
+                name: "MotionGlobalId",
+                table: "Motions",
+                type: "uuid",
+                nullable: false,
+                defaultValue: new Guid("00000000-0000-0000-0000-000000000000"),
+                oldClrType: typeof(Guid),
+                oldType: "uuid",
+                oldNullable: true);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Motions_GlobalMotions_MotionGlobalId",
+                table: "Motions",
+                column: "MotionGlobalId",
+                principalTable: "GlobalMotions",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230614183224_MotionCategoryFix3.Designer.cs

@@ -0,0 +1,608 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20230614183224_MotionCategoryFix3")]
+    partial class MotionCategoryFix3
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:CollationDefinition:my_ci_collation", "en-u-ks-primary,en-u-ks-primary,icu,False")
+                .HasAnnotation("ProductVersion", "7.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("AccountAccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountMinus")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountPlus")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MotionId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("MotionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("DefaultQuantity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Quantity")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("MotionGlobalId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("MotionGlobalId");
+
+                    b.ToTable("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("MotionCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionGlobal", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GlobalMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FullName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsEmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .UseCollation("my_ci_collation");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Categories")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Accounts.AccountCategory", "Category")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionAccount", "Motion")
+                        .WithMany("Motions")
+                        .HasForeignKey("MotionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", null)
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Motion");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionCategory", "Category")
+                        .WithMany("Motions")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionGlobal", "MotionGlobal")
+                        .WithMany("Motions")
+                        .HasForeignKey("MotionGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+
+                    b.Navigation("MotionGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("MotionCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Categories");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionGlobal", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountCategories");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("MotionCategories");
+
+                    b.Navigation("UserClaims");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/20230614183224_MotionCategoryFix3.cs

@@ -0,0 +1,60 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MyOffice.Migrations.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class MotionCategoryFix3 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Motions_GlobalMotions_MotionGlobalId",
+                table: "Motions");
+
+            migrationBuilder.AlterColumn<Guid>(
+                name: "MotionGlobalId",
+                table: "Motions",
+                type: "uuid",
+                nullable: false,
+                defaultValue: new Guid("00000000-0000-0000-0000-000000000000"),
+                oldClrType: typeof(Guid),
+                oldType: "uuid",
+                oldNullable: true);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Motions_GlobalMotions_MotionGlobalId",
+                table: "Motions",
+                column: "MotionGlobalId",
+                principalTable: "GlobalMotions",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Motions_GlobalMotions_MotionGlobalId",
+                table: "Motions");
+
+            migrationBuilder.AlterColumn<Guid>(
+                name: "MotionGlobalId",
+                table: "Motions",
+                type: "uuid",
+                nullable: true,
+                oldClrType: typeof(Guid),
+                oldType: "uuid");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Motions_GlobalMotions_MotionGlobalId",
+                table: "Motions",
+                column: "MotionGlobalId",
+                principalTable: "GlobalMotions",
+                principalColumn: "Id");
+        }
+    }
+}

MyOffice.Migration.Postgres/Migrations/AppDbContextModelSnapshot.cs

@@ -1,9 +1,9 @@
 // <auto-generated />
 using System;
-using MyOffice.DbContext;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MyOffice.DbContext;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 
 #nullable disable
@@ -23,12 +23,291 @@ namespace MyOffice.Migrations.Postgres.Migrations
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
 
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAllowManage")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAllowWrite")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountAccesses");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("AccountAccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("AmountMinus")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("AmountPlus")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MotionId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("MotionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccountMotions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CurrencyGlobalId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyGlobalId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyGlobal", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("DefaultQuantity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyGlobals");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyRate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CurrencyId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Quantity")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Rate")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrencyId");
+
+                    b.ToTable("CurrencyRates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("CategoryId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("MotionGlobalId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("MotionGlobalId");
+
+                    b.ToTable("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("MotionCategories");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionGlobal", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GlobalMotions");
+                });
+
             modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
                 {
                     b.Property<Guid>("Id")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("uuid");
 
+                    b.Property<string>("CurrencyId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
                     b.Property<string>("Email")
                         .IsRequired()
                         .HasColumnType("text")
@@ -60,6 +339,8 @@ namespace MyOffice.Migrations.Postgres.Migrations
 
                     b.HasKey("Id");
 
+                    b.HasIndex("CurrencyId");
+
                     b.ToTable("Users");
                 });
 
@@ -98,6 +379,160 @@ namespace MyOffice.Migrations.Postgres.Migrations
                     b.ToTable("UserClaims");
                 });
 
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccess", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("AccessRights")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountAccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Categories")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Accounts.AccountCategory", "Category")
+                        .WithMany("Accounts")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("AccountCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountMotion", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Accounts.Account", "Account")
+                        .WithMany("Motions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionAccount", "Motion")
+                        .WithMany("Motions")
+                        .HasForeignKey("MotionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", null)
+                        .WithMany("AccountMotions")
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Motion");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "CurrencyGlobal")
+                        .WithMany("Currencies")
+                        .HasForeignKey("CurrencyGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("Currencies")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CurrencyGlobal");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyRate", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.Currency", "Currency")
+                        .WithMany("Rates")
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionCategory", "Category")
+                        .WithMany("Motions")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MyOffice.Data.Models.Motions.MotionGlobal", "MotionGlobal")
+                        .WithMany("Motions")
+                        .HasForeignKey("MotionGlobalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+
+                    b.Navigation("MotionGlobal");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Users.User", "User")
+                        .WithMany("MotionCategories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
+                {
+                    b.HasOne("MyOffice.Data.Models.Currencies.CurrencyGlobal", "Currency")
+                        .WithMany()
+                        .HasForeignKey("CurrencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Currency");
+                });
+
             modelBuilder.Entity("MyOffice.Data.Models.Users.UserExternal", b =>
                 {
                     b.HasOne("MyOffice.Data.Models.Users.User", "User")
@@ -109,8 +544,59 @@ namespace MyOffice.Migrations.Postgres.Migrations
                     b.Navigation("User");
                 });
 
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.Account", b =>
+                {
+                    b.Navigation("AccessRights");
+
+                    b.Navigation("Categories");
+
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Accounts.AccountCategory", b =>
+                {
+                    b.Navigation("Accounts");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.Currency", b =>
+                {
+                    b.Navigation("Rates");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Currencies.CurrencyGlobal", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Currencies");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionAccount", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionCategory", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
+            modelBuilder.Entity("MyOffice.Data.Models.Motions.MotionGlobal", b =>
+                {
+                    b.Navigation("Motions");
+                });
+
             modelBuilder.Entity("MyOffice.Data.Models.Users.User", b =>
                 {
+                    b.Navigation("AccountAccess");
+
+                    b.Navigation("AccountCategories");
+
+                    b.Navigation("AccountMotions");
+
+                    b.Navigation("Currencies");
+
+                    b.Navigation("MotionCategories");
+
                     b.Navigation("UserClaims");
                 });
 #pragma warning restore 612, 618

MyOffice.SPA/angular.json

@@ -82,7 +82,8 @@
 					},
 					"defaultConfiguration": "development",
 					"options": {
-						"proxyConfig": "src/proxy.conf.js"
+						"proxyConfig": "src/proxy.conf.js",
+						"port": 4300
 					}
 				},
 				"extract-i18n": {

MyOffice.SPA/package.json

@@ -4,8 +4,7 @@
 	"scripts": {
 		"ng": "ng",
 		"start": "ng serve",
-		"start-ssl":
+		"start-ssl": "ng serve --ssl --ssl-cert %APPDATA%\\ASP.NET\\https\\%npm_package_name%.pem --ssl-key %APPDATA%\\ASP.NET\\https\\%npm_package_name%.key",
-			"ng serve --ssl --ssl-cert %APPDATA%\\ASP.NET\\https\\%npm_package_name%.pem --ssl-key %APPDATA%\\ASP.NET\\https\\%npm_package_name%.key",
 		"build": "ng build",
 		"watch": "ng build --watch --configuration development",
 		"test": "ng test",
@@ -26,6 +25,7 @@
 		"@angular/platform-browser": "^15.2.0",
 		"@angular/platform-browser-dynamic": "^15.2.0",
 		"@angular/router": "^15.2.0",
+		"@auth0/auth0-angular": "^2.0.2",
 		"@ckeditor/ckeditor5-angular": "^5.1.0",
 		"@ckeditor/ckeditor5-build-classic": "^36.0.1",
 		"@danielmoncada/angular-datetime-picker": "^15.0.2",
@@ -44,11 +44,10 @@
 		"@swimlane/ngx-charts": "^20.1.2",
 		"@swimlane/ngx-datatable": "^20.1.0",
 		"@types/d3-shape": "^3.1.1",
-		"angular-oauth2-oidc": "^15.0.1",
 		"angular-auth-oidc-client": "^15.0.3",
-		"@auth0/auth0-angular": "^2.0.2",
 		"angular-feather": "^6.5.0",
 		"angular-gauge": "^4.0.0",
+		"angular-oauth2-oidc": "^15.0.1",
 		"apexcharts": "^3.37.0",
 		"bootstrap": "^5.2.3",
 		"browser-sync": "^2.27.5",
@@ -59,6 +58,7 @@
 		"ng-apexcharts": "^1.7.4",
 		"ng-image-fullscreen-view": "^3.0.3",
 		"ng2-charts": "^4.1.1",
+		"ngx-currency": "^3.0.0",
 		"ngx-dropzone-wrapper": "^13.0.0",
 		"ngx-echarts": "^15.0.1",
 		"ngx-gauge": "^7.0.0",

MyOffice.SPA/src/app/api-routes.ts

@@ -1,7 +1,30 @@
-export enum ApiRoutes {
+export class ApiRoutes {
-	UserRegister = '/api/user/register',
+	static UserRegister = '/api/user/register';
-	UserLogin = '/api/user/login',
+	static UserLogin = '/api/user/login';
-	UserProfile = '/api/user/profile',
+	static UserProfile = '/api/user/profile';
-	UserAttach = '/api/user/attach',
+	static UserAttach = '/api/user/attach';
-	UserDeattach = '/api/user/deattach',
+	static UserDeattach = '/api/user/deattach';
+
+	static GeneralCurrencies = '/api/general/currencies';
+	static SettingsCurrencies = '/api/settings/currencies';
+	static SettingsCurrenciesRate = '/api/settings/currencies/:id/rate';
+
+	static SettingsAccountCategories = '/api/settings/account-categories';
+	static SettingsAccountCategory = '/api/settings/account-categories/:id';
+
+	static SettingsAccounts = '/api/settings/accounts';
+	static SettingsAccount = '/api/settings/accounts/:id';
+	static SettingsAccountAccountCategory = '/api/settings/accounts/:id/category/:categoryId';
+
+	static SettingsMotionCategories = '/api/settings/motion-categories';
+	static SettingsMotionCategory = '/api/settings/motion-categories/:id';
+
+	static SettingsMotions = '/api/settings/motions';
+	static SettingsMotion = '/api/settings/motions/:id';
+
+	static Accounts = '/api/accounts';
+	static Account = '/api/accounts/:id';
+
+	static Motions = '/api/accounts/:id/motions';
+	static Motion = '/api/accounts/:id/motions/:motionId';
 }

MyOffice.SPA/src/app/app.module.ts

@@ -25,6 +25,7 @@ import { AuthLayoutComponent } from './layout/app-layout/auth-layout/auth-layout
 import { MainLayoutComponent } from './layout/app-layout/main-layout/main-layout.component';
 import { ErrorInterceptor } from './core/interceptor/error.interceptor';
 import { JwtInterceptor } from './core/interceptor/jwt.interceptor';
+import { UpdateDateHttpInterceptor } from './core/interceptor/update.date.http.interceptor ';
 
 export function createTranslateLoader(http: HttpClient) {
 	return new TranslateHttpLoader(http, 'assets/i18n/', '.json');
@@ -63,6 +64,7 @@ export function createTranslateLoader(http: HttpClient) {
 		{ provide: LocationStrategy, useClass: HashLocationStrategy },
 		{ provide: HTTP_INTERCEPTORS, useClass: JwtInterceptor, multi: true },
 		{ provide: HTTP_INTERCEPTORS, useClass: ErrorInterceptor, multi: true },
+		{ provide: HTTP_INTERCEPTORS, useClass: UpdateDateHttpInterceptor, multi: true },
 	],
 	bootstrap: [AppComponent],
 })

MyOffice.SPA/src/app/authentication/signin/signin.component.html

@@ -73,7 +73,7 @@
 					</form>
 					<h6 class="social-login-title">OR</h6>
 					<ul class="list-unstyled social-icon mb-0 mt-3">
-						<li class="list-inline-item">
+						<li class="list-inline-item" *ngIf="allowAuth">
 							<a href="javascript:void(0)" class="rounded" (click)="loginAuth0()">
 								<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 135 150">
 									<title>auth0-glyph</title>
@@ -81,7 +81,7 @@
 								</svg>
 							</a>
 						</li>
-						<li class="list-inline-item">
+						<li class="list-inline-item" *ngIf="allowGoogle">
 							<!--
 							<a href="javascript:void(0)" class="rounded" (click)="loginGoogle()">
 								<i class="fab fa-google"></i>

MyOffice.SPA/src/app/authentication/signin/signin.component.ts

@@ -9,6 +9,7 @@ import { SocialAuthService } from '@abacritt/angularx-social-login';
 // app
 import { AuthService } from 'src/app/core/service/auth.service';
 import { UnsubscribeOnDestroyAdapter } from 'src/app/shared/UnsubscribeOnDestroyAdapter';
+import { environment } from '../../../environments/environment';
 
 @Component({
 	selector: 'app-signin',
@@ -22,15 +23,24 @@ implements OnInit {
 	loading = false;
 	error?= '';
 	hide = true;
+	allowGoogle: boolean;
+	allowAuth: boolean;
 
 	constructor(
 		private formBuilder: UntypedFormBuilder,
 		private router: Router,
 		private route: ActivatedRoute,
 		private authService: AuthService,
-		//private externalAuthService: SocialAuthService,
 	) {
 		super();
+
+		this.allowGoogle = !!(environment.externalLogins &&
+			environment.externalLogins.google &&
+			environment.externalLogins.google.clientId);
+
+		this.allowAuth = !!(environment.externalLogins &&
+			environment.externalLogins.auth0 &&
+			environment.externalLogins.auth0.clientId);
 	}
 
 	ngOnInit() {

MyOffice.SPA/src/app/config.external-login.ts

@@ -48,7 +48,6 @@ export class ExternalLoginConfig {
 				)
 			});
 		}
-
 		return {
 			autoLogin: false,
 			providers: providers,

MyOffice.SPA/src/app/core/core.module.ts

@@ -18,6 +18,7 @@ import { OidcHelperService } from './service/oidc-helper.service';
 import { AuthCodeFlowConfig, AuthModuleConfig } from '../config.oidc';
 import { SubjectExtensions } from './extensions/general.extensions';
 import { ExternalLoginConfig } from '../config.external-login';
+import { AccountCategoryService } from '../services/account.category.service';
 
 export function storageFactory(): OAuthStorage {
 	return localStorage;
@@ -43,6 +44,7 @@ export function storageFactory(): OAuthStorage {
 		DirectionService,
 		OidcHelperService,
 		SubjectExtensions,
+		AccountCategoryService,
 	],
 	schemas: [
 		CUSTOM_ELEMENTS_SCHEMA

MyOffice.SPA/src/app/core/interceptor/update.date.http.interceptor .ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { HttpInterceptor } from '@angular/common/http';
+import { HttpRequest } from '@angular/common/http';
+import { HttpHandler } from '@angular/common/http';
+import { HttpEvent } from '@angular/common/http';
+
+
+@Injectable()
+export class UpdateDateHttpInterceptor implements HttpInterceptor {
+
+	intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+		if (request.method === 'POST' || request.method === 'PUT') {
+			this.shiftDates(request.body);
+		}
+
+		return next.handle(request);
+	}
+
+	shiftDates(body: any) {
+		if (body === null || body === undefined) {
+			return body;
+		}
+
+		if (typeof body !== 'object') {
+			return body;
+		}
+
+		for (const key of Object.keys(body)) {
+			const value = body[key];
+			if (value instanceof Date) {
+				body[key] = new Date(Date.UTC(value.getFullYear(),
+					value.getMonth(),
+					value.getDate(),
+					value.getHours(),
+					value.getMinutes(),
+					value.getSeconds()));
+			} else if (typeof value === 'object') {
+				this.shiftDates(value);
+			}
+		}
+	}
+}

MyOffice.SPA/src/app/core/models/user-profile.model.ts

@@ -5,4 +5,5 @@ export interface UserProfileModel {
 	firstName?: string;
 	lastName?: string;
 	fullName?: string;
+	currency?: string;
 }

MyOffice.SPA/src/app/core/models/user.model.ts

@@ -1,8 +1,9 @@
 export interface UserModel {
 	id: string;
-	username: string;
+	userName: string;
 	img?: string;
 	firstName?: string;
 	lastName?: string;
+	email?: string;
 	//token?: string;
 }

MyOffice.SPA/src/app/core/service/auth.service.ts

@@ -97,7 +97,7 @@ export class AuthService {
 		this.currentUserSubject.next({
 			id: id,
 			img: 'assets/images/user/admin.jpg',
-			username: profile?.email || '',
+			userName: profile?.email || '',
 			firstName: profile?.firstName || '',
 			lastName: profile?.lastName || '',
 		});

MyOffice.SPA/src/app/core/validators/atleastone.validator.ts

@@ -0,0 +1,21 @@
+import {
+	FormGroup,
+	ValidationErrors,
+	ValidatorFn,
+	Validators,
+} from '@angular/forms';
+
+export const atLeastOne = (validator: ValidatorFn, controls: string[] = []) => (
+	group: FormGroup,
+): ValidationErrors | null => {
+	if (!controls) {
+		controls = Object.keys(group.controls);
+	}
+
+	const hasAtLeastOne = group && group.controls && controls
+		.some(k => !validator(group.controls[k]));
+
+	return hasAtLeastOne ? null : {
+		atLeastOne: true,
+	};
+};

MyOffice.SPA/src/app/core/validators/atleastonenumber.validator.ts

@@ -0,0 +1,24 @@
+import {
+	FormGroup,
+	ValidationErrors,
+	ValidatorFn,
+	Validators,
+} from '@angular/forms';
+
+export const atLeastOneNumber = (validator: ValidatorFn, controls: string[] = []) => (
+	group: FormGroup,
+): ValidationErrors | null => {
+	if (!controls) {
+		controls = Object.keys(group.controls);
+	}
+
+	const hasAtLeastOne = group && group.controls && controls
+		.some(k => {
+			var v = group.controls[k].value;
+			return v && !isNaN(v) && v !== 0 && !validator(group.controls[k]);
+		});
+
+	return hasAtLeastOne ? null : {
+		atLeastOne: true,
+	};
+};

MyOffice.SPA/src/app/layout/header/header.component.ts

@@ -254,6 +254,6 @@ export class HeaderComponent extends UnsubscribeOnDestroyAdapter implements OnIn
 			this.authService.currentUserValue.lastName
 		].join(' ').trim();
 
-		this.userName = this.userName || this.authService.currentUserValue.username;
+		this.userName = this.userName || this.authService.currentUserValue.userName;
 	}
 }

MyOffice.SPA/src/app/layout/sidebar/sidebar-items.ts

@@ -1,4 +1,5 @@
 import { RouteInfo } from './sidebar.metadata';
+
 export const ROUTES: RouteInfo[] = [
 	{
 		path: '',
@@ -104,31 +105,9 @@ export const ROUTES: RouteInfo[] = [
 		],
 	},
 	{
+		id: 'accounts',
 		path: '',
-		title: 'Extra Pages',
+		title: 'Accounts',
-		iconType: 'feather',
-		icon: 'anchor',
-		class: 'menu-toggle',
-		groupTitle: false,
-		badge: '',
-		badgeClass: '',
-		submenu: [
-			{
-				path: '/extra-pages/blank',
-				title: 'Blank Page',
-				iconType: '',
-				icon: '',
-				class: 'ml-menu',
-				groupTitle: false,
-				badge: '',
-				badgeClass: '',
-				submenu: [],
-			},
-		],
-	},
-	{
-		path: '',
-		title: 'Multi level Menu',
 		iconType: 'feather',
 		icon: 'chevrons-down',
 		class: 'menu-toggle',
@@ -136,7 +115,7 @@ export const ROUTES: RouteInfo[] = [
 		badge: '',
 		badgeClass: '',
 		submenu: [
-			{
+			/*{
 				path: '/multilevel/first1',
 				title: 'First',
 				iconType: '',
@@ -203,6 +182,73 @@ export const ROUTES: RouteInfo[] = [
 				badge: '',
 				badgeClass: '',
 				submenu: [],
+			},*/
+		],
+	},
+	{
+		path: '',
+		title: 'Settings',
+		iconType: 'feather',
+		icon: 'settings',
+		class: 'menu-toggle',
+		groupTitle: false,
+		badge: '',
+		badgeClass: '',
+		submenu: [
+			{
+				path: '/settings/currencies',
+				title: 'Currencies',
+				iconType: '',
+				icon: '',
+				class: 'ml-menu',
+				groupTitle: false,
+				badge: '',
+				badgeClass: '',
+				submenu: [],
+			},
+			{
+				path: '/settings/account-categories',
+				title: 'Account categories',
+				iconType: '',
+				icon: '',
+				class: 'ml-menu',
+				groupTitle: false,
+				badge: '',
+				badgeClass: '',
+				submenu: [],
+			},
+			{
+				path: '/settings/accounts',
+				title: 'Accounts',
+				iconType: '',
+				icon: '',
+				class: 'ml-menu',
+				groupTitle: false,
+				badge: '',
+				badgeClass: '',
+				submenu: [],
+			},
+			{
+				path: '/settings/motion-categories',
+				title: 'Motion categories',
+				iconType: '',
+				icon: '',
+				class: 'ml-menu',
+				groupTitle: false,
+				badge: '',
+				badgeClass: '',
+				submenu: [],
+			},
+			{
+				path: '/settings/motions',
+				title: 'Motions',
+				iconType: '',
+				icon: '',
+				class: 'ml-menu',
+				groupTitle: false,
+				badge: '',
+				badgeClass: '',
+				submenu: [],
 			},
 		],
 	},

MyOffice.SPA/src/app/layout/sidebar/sidebar.component.ts

@@ -7,6 +7,7 @@ import { Component, Inject, ElementRef, OnInit, Renderer2, HostListener, OnDestr
 // app
 import { ROUTES } from './sidebar-items';
 import { AuthService } from 'src/app/core/service/auth.service';
+import { AccountCategoryService } from '../../services/account.category.service';
 import { RouteInfo } from './sidebar.metadata';
 
 @Component({
@@ -33,7 +34,8 @@ export class SidebarComponent implements OnInit, OnDestroy {
 		private renderer: Renderer2,
 		public elementRef: ElementRef,
 		private authService: AuthService,
-		private router: Router
+		private router: Router,
+		private accountCategoryService: AccountCategoryService,
 	) {
 		this.elementRef.nativeElement.closest('body');
 		this.routerObj = this.router.events.subscribe((event) => {
@@ -79,6 +81,26 @@ export class SidebarComponent implements OnInit, OnDestroy {
 			this.userImg = this.authService.currentUserValue.img;
 			this.userType = 'Admin';
 			this.sidebarItems = ROUTES.filter((sidebarItem) => sidebarItem);
+
+			this.accountCategoryService
+				.getCategories()
+				.subscribe(categories => {
+					var accounts = this.sidebarItems.filter(x => x.id === 'accounts');
+					for (var category of categories) {
+						accounts[0].submenu.push({
+							path: '/account-category/' + category.id,
+							title: category.name!,
+							iconType: '',
+							icon: '',
+							class: 'ml-menu',
+							groupTitle: false,
+							badge: '',
+							badgeClass: '',
+							submenu: [],
+
+						});
+		}
+				});
 		}
 
 		// this.sidebarItems = ROUTES.filter((sidebarItem) => sidebarItem);

MyOffice.SPA/src/app/layout/sidebar/sidebar.metadata.ts

@@ -1,5 +1,6 @@
 // Sidebar route metadata
 export interface RouteInfo {
+	id?: string;
 	path: string;
 	title: string;
 	iconType: string;

MyOffice.SPA/src/app/model/account.accessRight.model.ts

@@ -0,0 +1,8 @@
+import { UserModel } from '../core/models/user.model';
+
+export interface AccountAccessRightModel {
+	user: UserModel;
+	isAllowRead: boolean;
+	isAllowWrite: boolean;
+	isAllowManage: boolean;
+}

MyOffice.SPA/src/app/model/account.category.model.ts

@@ -0,0 +1,5 @@
+export interface AccountCategoryModel {
+	id?: string,
+	name?: string,
+	allowDelete: boolean,
+}

MyOffice.SPA/src/app/model/account.detailed.model.ts

@@ -0,0 +1,6 @@
+import { AccountModel } from './account.model';
+
+export interface AccountDetailedModel {
+	account: AccountModel;
+	rest: number;
+}

MyOffice.SPA/src/app/model/account.model.ts

@@ -0,0 +1,11 @@
+import { AccountCategoryModel } from './account.category.model';
+import { AccountAccessRightModel } from './account.accessRight.model';
+
+export interface AccountModel {
+	id?: string,
+	name?: string,
+	currencyId?: string,
+	currencyName?: string,
+	categories?: AccountCategoryModel[],
+	accessRights?: AccountAccessRightModel[],
+}

MyOffice.SPA/src/app/model/account.motion.ts

@@ -0,0 +1,8 @@
+export interface AccountMotionModel {
+	id?: string;
+	date?: Date;
+	motion?: string;
+	description?: string;
+	plus?: number;
+	minus?: number;
+}

MyOffice.SPA/src/app/model/currency.model.ts

@@ -0,0 +1,11 @@
+export interface CurrencyModel {
+	id?: string,
+	name?: string,
+	code?: string,
+	shortName?: string,
+	symbol?: string,
+	quantity?: number,
+	rate?: number,
+	rateDate?: Date,
+	isConnected?: boolean,
+}

MyOffice.SPA/src/app/model/motion.category.model.ts

@@ -0,0 +1,5 @@
+export interface MotionCategoryModel {
+	id?: string,
+	name?: string,
+	allowDelete: boolean,
+}

MyOffice.SPA/src/app/model/motion.model.ts

@@ -0,0 +1,7 @@
+export interface MotionModel {
+	id?: string,
+	name?: string,
+	categoryId?: string,
+	category?: string,
+	allowDelete: boolean,
+}

MyOffice.SPA/src/app/pages/accounts/account.component.html

@@ -0,0 +1,30 @@
+<section class="content">
+	<div class="content-block">
+		<div class="block-header">
+			<!-- breadcrumb -->
+			<app-breadcrumb [title]="'Blank'" [items]="['Home','Settings']" [active_item]="'Accounts'">
+			</app-breadcrumb>
+		</div>
+		<div class="row clearfix">
+			<div class="col-xs-12 col-sm-12 col-md-12 col-lg-12">
+				<mat-accordion class="main-headers-align" multi>
+					<mat-expansion-panel *ngFor="let account of accounts; let i = index" [expanded]="i === 0" >
+						<mat-expansion-panel-header>
+							<mat-panel-description>
+								<div>{{account.account.name}}</div>
+								<div>
+									{{account.rest}}
+									({{account.account.currencyId}})
+								</div>
+							</mat-panel-description>
+						</mat-expansion-panel-header>
+						<account-motion [motion]="newMotion">
+						</account-motion>
+						<account-motion *ngFor="let motion of motions" [motion]="motion">
+						</account-motion>
+					</mat-expansion-panel>
+				</mat-accordion>
+			</div>
+		</div>
+	</div>
+</section>

MyOffice.SPA/src/app/pages/accounts/account.component.ts

@@ -0,0 +1,91 @@
+// angular
+import { Component } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { ActivatedRoute } from '@angular/router';
+
+// libs
+import Swal from 'sweetalert2';
+import { MatDialog } from '@angular/material/dialog';
+
+// app
+import { AccountCategoryService } from '../../services/account.category.service';
+import { ApiRoutes } from '../../api-routes';
+import { AccountCategoryModel } from '../../model/account.category.model';
+import { SettingsAccountAddComponent } from '../settings/account/add.account.component';
+import { SettingsAccountEditComponent } from '../settings/account/edit.account.component';
+import { AccountModel } from '../../model/account.model';
+import { AccountDetailedModel } from '../../model/account.detailed.model';
+import { AccountMotionModel } from '../../model/account.motion';
+
+@Component({
+	templateUrl: './account.component.html',
+	styleUrls: ['./account.component.scss'],
+})
+export class AccountComponent {
+	public accounts?: AccountDetailedModel[];
+	public motions?: AccountMotionModel[];
+	public newMotion: AccountMotionModel;
+
+	constructor(
+		private httpClient: HttpClient,
+		private dialogModel: MatDialog,
+		private activatedRoute: ActivatedRoute
+	) {
+		this.newMotion = {
+			date: new Date(),
+		};
+	}
+
+	ngOnInit(): void {
+		this.activatedRoute.params.subscribe(params => {
+			this.httpClient
+				.get<AccountDetailedModel[]>(ApiRoutes.Accounts + "?category=" + params['id'])
+				.subscribe(data => {
+					this.accounts = data;
+				});
+		});
+	}
+
+	/*private loadAccounts() {
+	}*/
+
+	/*private loadCategories() {
+		this.accountCategoryService
+			.getCategories()
+			.subscribe(x => {
+				this.accountCategories = x;
+				this.loadAccounts();
+			});
+	}*/
+
+	/*public accountInCategory(category?: AccountCategoryModel) {
+		if (this.accounts) {
+			return this.accounts.filter(acc => (!category && (!acc.categories || acc.categories.length === 0)) || (category && acc.categories && acc.categories.filter(cat => cat.id === category.id).length > 0));
+		}
+		return null;
+	}*/
+
+	/*public add() {
+		this.dialogModel.open(SettingsAccountAddComponent, {
+			width: '640px',
+			disableClose: true,
+			data: this.accounts,
+		}).afterClosed().subscribe(x => {
+			if (x && x.refresh) {
+				this.loadAccounts();
+			}
+		});
+	}*/
+
+	/*public edit(account: AccountModel) {
+		this.dialogModel.open(SettingsAccountEditComponent, {
+			width: '640px',
+			disableClose: true,
+			data: account,
+		}).afterClosed().subscribe(x => {
+			if (x && x.refresh) {
+				this.loadAccounts();
+			}
+		});
+	}*/
+}

MyOffice.SPA/src/app/pages/accounts/motion.component.html

@@ -0,0 +1,55 @@
+<form [formGroup]="form!" (ngSubmit)="onSubmitClick()">
+	<div class="row">
+		<div class="col-md-4">
+			<div style="display: flex; align-items: center;">
+				<a href="javascript:void(0)" matSuffix (click)="addDay(-1)">
+					<i class="material-icons font-40">arrow_back</i>
+				</a>
+
+				<mat-form-field class="example-full-width" appearance="fill">
+					<input matInput [matDatepicker]="picker3" (focus)="picker3.open()" value={{motion.date}} formControlName="date" required>
+					<mat-hint>YYYY/MM/DD</mat-hint>
+					<mat-datepicker-toggle tabindex="-1" matSuffix [for]="picker3"></mat-datepicker-toggle>
+					<mat-datepicker #picker3></mat-datepicker>
+					<mat-error *ngIf="form.controls?.['date']?.hasError('required')">
+						Please enter rate date
+					</mat-error>
+				</mat-form-field>
+
+				<a href="javascript:void(0)" matSuffix (click)="addDay(1)">
+					<i class="material-icons font-40">arrow_forward</i>
+				</a>
+			</div>
+		</div>
+		<div class="col-md-4">
+			<mat-form-field class="example-full-width" appearance="fill">
+				<input matInput formControlName="motion">
+			</mat-form-field>
+			<mat-form-field class="example-full-width" appearance="fill">
+				<input matInput formControlName="description">
+			</mat-form-field>
+		</div>
+		<div class="col-md-2">
+			<mat-form-field class="example-full-width" appearance="fill">
+				<input matInput [value]="motion.plus | number:'0.2-2'" formControlName="plus" currencyMask [options]="{ prefix: '', precision: 4, inputMode: 1 }">
+			</mat-form-field>
+			<mat-form-field class="example-full-width" appearance="fill">
+				<input matInput [value]="motion.minus | number:'0.2-2'" formControlName="minus" currencyMask [options]="{ prefix: '', precision: 4, inputMode: 1 }">
+			</mat-form-field>
+		</div>
+		<div class="col-md-2 mb-2">
+			<a *ngIf="!motion.id" href="javascript:void(0)" (click)="onSubmitClick()">
+				<i class="material-icons font-40">add</i>
+			</a>
+			<a *ngIf="!motion.id" href="javascript:void(0)" (click)="onSubmitClick()">
+				<i class="material-icons font-40">import_export</i>
+			</a>
+			<a *ngIf="motion.id" href="javascript:void(0)" (click)="onSubmitClick()">
+				<i class="material-icons font-40">save</i>
+			</a>
+			<a *ngIf="motion.id" href="javascript:void(0)" (click)="onSubmitClick()">
+				<i class="material-icons font-40">delete</i>
+			</a>
+		</div>
+	</div>
+</form>

MyOffice.SPA/src/app/pages/accounts/motion.component.ts

@@ -0,0 +1,90 @@
+// angular
+import { Component } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { ActivatedRoute } from '@angular/router';
+import { UntypedFormBuilder } from '@angular/forms';
+import { Validators } from '@angular/forms';
+import { UntypedFormGroup } from '@angular/forms';
+import { Input } from '@angular/core';
+import { Output } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+
+// libs
+import Swal from 'sweetalert2';
+import { MatDialog } from '@angular/material/dialog';
+import * as moment from 'moment';
+
+// app
+import { AccountCategoryService } from '../../services/account.category.service';
+import { ApiRoutes } from '../../api-routes';
+import { AccountCategoryModel } from '../../model/account.category.model';
+import { SettingsAccountAddComponent } from '../settings/account/add.account.component';
+import { SettingsAccountEditComponent } from '../settings/account/edit.account.component';
+import { AccountModel } from '../../model/account.model';
+import { AccountDetailedModel } from '../../model/account.detailed.model';
+import { AccountMotionModel } from '../../model/account.motion';
+import { atLeastOne } from '../../core/validators/atleastone.validator';
+import { atLeastOneNumber } from '../../core/validators/atleastonenumber.validator';
+
+@Component({
+	selector: 'account-motion',
+	templateUrl: './motion.component.html',
+	styleUrls: ['./motion.component.scss'],
+})
+export class MotionComponent {
+	public form!: UntypedFormGroup;
+	public errorMessage?: string;
+
+	@Input() motion!: AccountMotionModel;
+
+	constructor(
+		private fb: UntypedFormBuilder,
+		private httpClient: HttpClient,
+		private dialogModel: MatDialog,
+		private activatedRoute: ActivatedRoute
+	) {
+	}
+
+	ngOnInit(): void {
+		this.form = this.fb.group({
+			id: [
+				this.motion.id,
+			],
+			date: [
+				this.motion.date,
+				[Validators.required],
+			],
+			motion: [
+				this.motion.motion,
+				[Validators.required],
+			],
+			description: [
+				this.motion.description,
+			],
+			plus: [
+				this.motion.plus,
+			],
+			minus: [
+				this.motion.minus,
+			],
+		}, { validator: atLeastOneNumber(Validators.required, ['plus', 'minus']) });
+	}
+
+	onSubmitClick() {
+		if (this.form.valid) {
+			this.httpClient
+				.post<AccountMotionModel[]>(ApiRoutes.SettingsCurrencies, this.form.value)
+				.subscribe(response => {
+				}, error => {
+					this.errorMessage = error.detail;
+				});
+		}
+	}
+
+	addDay(days: number) {
+		var date = moment(this.form!.get('date')!.value).add(days, 'days').toDate();
+		this.form.patchValue({
+			date: date,
+		});
+	}
+}

MyOffice.SPA/src/app/pages/pages-routing.module.ts

@@ -1,6 +1,12 @@
 import { NgModule } from '@angular/core';
 import { Routes, RouterModule } from '@angular/router';
 import { UserProfileComponent } from './user-profile/user-profile.component';
+import { SettingsCurrencyComponent } from './settings/currency/currency.component';
+import { SettingsAccountCategoryComponent } from './settings/account/account.category.component';
+import { SettingsAccountComponent } from './settings/account/account.component';
+import { SettingsMotionCategoryComponent } from './settings/motion/motion.category.component';
+import { SettingsMotionComponent } from './settings/motion/motion.component';
+import { AccountComponent } from './accounts/account.component';
 
 const routes: Routes = [
 	{
@@ -12,6 +18,30 @@ const routes: Routes = [
 		path: 'user/profile',
 		component: UserProfileComponent,
 	},
+	{
+		path: 'settings/currencies',
+		component: SettingsCurrencyComponent,
+	},
+	{
+		path: 'settings/account-categories',
+		component: SettingsAccountCategoryComponent,
+	},
+	{
+		path: 'settings/accounts',
+		component: SettingsAccountComponent,
+	},
+	{
+		path: 'settings/motion-categories',
+		component: SettingsMotionCategoryComponent,
+	},
+	{
+		path: 'settings/motions',
+		component: SettingsMotionComponent,
+	},
+	{
+		path: 'account-category/:id',
+		component: AccountComponent,
+	},
 ];
 
 @NgModule({