initial commit of source

src/Api/Models/Request/Accounts/EmailRequestModel.cs

@@ -0,0 +1,19 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models
+{
+    public class EmailRequestModel
+    {
+        [Required]
+        [EmailAddress]
+        public string NewEmail { get; set; }
+        [Required]
+        public string MasterPasswordHash { get; set; }
+        [Required]
+        public string NewMasterPasswordHash { get; set; }
+        [Required]
+        public string Token { get; set; }
+        [Required]
+        public CipherRequestModel[] Ciphers { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/EmailTokenRequestModel.cs

@@ -0,0 +1,13 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models
+{
+    public class EmailTokenRequestModel
+    {
+        [Required]
+        [EmailAddress]
+        public string NewEmail { get; set; }
+        [Required]
+        public string MasterPasswordHash { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/PasswordHintRequestModel.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models
+{
+    public class PasswordHintRequestModel
+    {
+        [Required]
+        [EmailAddress]
+        public string Email { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/PasswordRequestModel.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models
+{
+    public class PasswordRequestModel
+    {
+        [Required]
+        public string MasterPasswordHash { get; set; }
+        [Required]
+        public string NewMasterPasswordHash { get; set; }
+        [Required]
+        public CipherRequestModel[] Ciphers { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/RegisterRequestModel.cs

@@ -0,0 +1,29 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Domains;
+
+namespace Bit.Api.Models
+{
+    public class RegisterRequestModel
+    {
+        [Required]
+        public string Token { get; set; }
+        [Required]
+        public string Name { get; set; }
+        [Required]
+        [EmailAddress]
+        public string Email { get; set; }
+        [Required]
+        public string MasterPasswordHash { get; set; }
+        public string MasterPasswordHint { get; set; }
+
+        public User ToUser()
+        {
+            return new User
+            {
+                Name = Name,
+                Email = Email,
+                MasterPasswordHint = MasterPasswordHint
+            };
+        }
+    }
+}

src/Api/Models/Request/Accounts/RegisterTokenRequestModel.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models
+{
+    public class RegisterTokenRequestModel
+    {
+        [Required]
+        [EmailAddress]
+        public string Email { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/SecurityStampRequestModel.cs

@@ -0,0 +1,10 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models
+{
+    public class SecurityStampRequestModel
+    {
+        [Required]
+        public string MasterPasswordHash { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/UpdateProfileRequestModel.cs

@@ -0,0 +1,24 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Domains;
+
+namespace Bit.Api.Models
+{
+    public class UpdateProfileRequestModel
+    {
+        [Required]
+        public string Name { get; set; }
+        public string MasterPasswordHint { get; set; }
+        [Required]
+        [RegularExpression("^[a-z]{2}-[A-Z]{2}$")]
+        public string Culture { get; set; }
+
+        public User ToUser(User existingUser)
+        {
+            existingUser.Name = Name;
+            existingUser.MasterPasswordHint = string.IsNullOrWhiteSpace(MasterPasswordHint) ? null : MasterPasswordHint;
+            existingUser.Culture = Culture;
+
+            return existingUser;
+        }
+    }
+}

src/Api/Models/Request/Accounts/UpdateTwoFactorRequestModel.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models
+{
+    public class UpdateTwoFactorRequestModel : IValidatableObject
+    {
+        [Required]
+        public string MasterPasswordHash { get; set; }
+        [Required]
+        public bool? Enabled { get; set; }
+        public string Token { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if(Enabled.HasValue && Enabled.Value && string.IsNullOrWhiteSpace(Token))
+            {
+                yield return new ValidationResult("Token is required.", new[] { "Token" });
+            }
+        }
+    }
+}

src/Api/Models/Request/Auth/AuthTokenRequestModel.cs

@@ -0,0 +1,13 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models
+{
+    public class AuthTokenRequestModel
+    {
+        [Required]
+        [EmailAddress]
+        public string Email { get; set; }
+        [Required]
+        public string MasterPasswordHash { get; set; }
+    }
+}

src/Api/Models/Request/Auth/AuthTokenTwoFactorRequestModel.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models
+{
+    public class AuthTokenTwoFactorRequestModel
+    {
+        [Required]
+        public string Code { get; set; }
+        [Required]
+        public string Provider { get; set; }
+    }
+}

src/Api/Models/Request/Ciphers/CipherRequestModel.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Api.Utilities;
+using Bit.Core.Domains;
+using System.Linq;
+using Bit.Core.Enums;
+
+namespace Bit.Api.Models
+{
+    public class CipherRequestModel : IValidatableObject
+    {
+        public CipherType Type { get; set; }
+
+        [Required]
+        public string Id { get; set; }
+        public string FolderId { get; set; }
+        [Required]
+        [EncryptedString]
+        public string Name { get; set; }
+        [EncryptedString]
+        public string Uri { get; set; }
+        [EncryptedString]
+        public string Username { get; set; }
+        [EncryptedString]
+        public string Password { get; set; }
+        [EncryptedString]
+        public string Notes { get; set; }
+
+        public virtual Site ToSite(string userId = null)
+        {
+            return new Site
+            {
+                Id = Id,
+                UserId = userId,
+                FolderId = string.IsNullOrWhiteSpace(FolderId) ? null : FolderId,
+                Name = Name,
+                Uri = Uri,
+                Username = Username,
+                Password = Password,
+                Notes = string.IsNullOrWhiteSpace(Notes) ? null : Notes
+            };
+        }
+
+        public Folder ToFolder(string userId = null)
+        {
+            return new Folder
+            {
+                Id = Id,
+                UserId = userId,
+                Name = Name
+            };
+        }
+
+        public static IEnumerable<dynamic> ToDynamicCiphers(CipherRequestModel[] models, string userId)
+        {
+            var sites = models.Where(m => m.Type == CipherType.Site).Select(m => m.ToSite(userId)).ToList();
+            var folders = models.Where(m => m.Type == CipherType.Folder).Select(m => m.ToFolder(userId)).ToList();
+
+            var ciphers = new List<dynamic>();
+            ciphers.AddRange(sites);
+            ciphers.AddRange(folders);
+            return ciphers;
+        }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if(Type == CipherType.Site)
+            {
+                if(string.IsNullOrWhiteSpace(Uri))
+                {
+                    yield return new ValidationResult("Uri is required for a site cypher.", new[] { "Uri" });
+                }
+                if(string.IsNullOrWhiteSpace(Username))
+                {
+                    yield return new ValidationResult("Username is required for a site cypher.", new[] { "Username" });
+                }
+                if(string.IsNullOrWhiteSpace(Password))
+                {
+                    yield return new ValidationResult("Password is required for a site cypher.", new[] { "Password" });
+                }
+            }
+        }
+    }
+}

src/Api/Models/Request/Folders/FolderRequestModel.cs

@@ -0,0 +1,30 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Bit.Api.Utilities;
+using Bit.Core.Domains;
+
+namespace Bit.Api.Models
+{
+    public class FolderRequestModel
+    {
+        [Required]
+        [EncryptedString]
+        public string Name { get; set; }
+
+        public Folder ToFolder(string userId = null)
+        {
+            return new Folder
+            {
+                UserId = userId,
+                Name = Name
+            };
+        }
+
+        public Folder ToFolder(Folder existingFolder)
+        {
+            existingFolder.Name = Name;
+
+            return existingFolder;
+        }
+    }
+}

src/Api/Models/Request/Sites/SiteRequestModel.cs

@@ -0,0 +1,52 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Bit.Api.Utilities;
+using Bit.Core.Domains;
+
+namespace Bit.Api.Models
+{
+    public class SiteRequestModel
+    {
+        public string FolderId { get; set; }
+        [Required]
+        [EncryptedString]
+        public string Name { get; set; }
+        [Required]
+        [EncryptedString]
+        public string Uri { get; set; }
+        [Required]
+        [EncryptedString]
+        public string Username { get; set; }
+        [Required]
+        [EncryptedString]
+        public string Password { get; set; }
+        [EncryptedString]
+        public string Notes { get; set; }
+
+        public Site ToSite(string userId = null)
+        {
+            return new Site
+            {
+                UserId = userId,
+                FolderId = string.IsNullOrWhiteSpace(FolderId) ? null : FolderId,
+                Name = Name,
+                Uri = Uri,
+                Username = Username,
+                Password = Password,
+                Notes = string.IsNullOrWhiteSpace(Notes) ? null : Notes
+            };
+        }
+
+        public Site ToSite(Site existingSite)
+        {
+            existingSite.FolderId = string.IsNullOrWhiteSpace(FolderId) ? null : FolderId;
+            existingSite.Name = Name;
+            existingSite.Uri = Uri;
+            existingSite.Username = Username;
+            existingSite.Password = Password;
+            existingSite.Notes = string.IsNullOrWhiteSpace(Notes) ? null : Notes;
+
+            return existingSite;
+        }
+    }
+}