public ActionResult Index()
{
using (CryptoDbContext db = new CryptoDbContext())
{
return(View(db.UserAccount.ToList()));
}
}
public static CryptoDbContext Create()
{
var options = new DbContextOptionsBuilder <CryptoDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var context = new CryptoDbContext(options);
context.Database.EnsureCreated();
//Add Test data
context.Coins.AddRange(new[] {
new Coin {
Symbol = "BTC"
},
new Coin {
Symbol = "ETH"
},
new Coin {
Symbol = "XRP"
}
});
return(context);
}
private ImageDetails SetImageDetails(string senderId, string receiverId)
{
var imageDetails = new ImageDetails();
watchAesEncrypt = new Stopwatch();
watchAesEncrypt.Start();
var aesEncrypt = new AESEncryption <Parameters>(SetParameters());
var IV = aesEncrypt.GenerateAesKeys();
var encryptParameters = aesEncrypt.EncryptAES();
watchAesEncrypt.Stop();
AesEncryptTime = watchAesEncrypt.ElapsedMilliseconds;
using (CryptoDbContext db = new CryptoDbContext())
{
imageDetails.SenderId = senderId;
imageDetails.ReceiverId = receiverId;
imageDetails.Parameters = encryptParameters;
imageDetails.IVAes = IV;
imageDetails.Image = null;
imageDetails.ImageId = Guid.NewGuid().ToString();
db.ImageDetails.Add(imageDetails);
db.SaveChanges();
}
return(imageDetails);
}
public ActionResult ImageString(SendDetails senderJson)
{
watchSend = new Stopwatch();
watchSend.Start();
var crtUser = SessionManager.ReturnSessionObject("User") as UserAccount;
if (ModelState.IsValid)
{
if (crtUser == null)
{
return(RedirectToAction("Login"));
}
using (CryptoDbContext db = new CryptoDbContext())
{
var imageDetails = db.ImageDetails.Find(senderJson.ImageId);
if (imageDetails == null)
{
ViewBag.Message = "Error something was wrong!";
return(null);
}
imageDetails.Image = senderJson.Image;
db.SaveChanges();
watchSend.Stop();
SendImageTime2 = watchSend.ElapsedMilliseconds;
ViewBag.Message = "The image was successfully add in Database!";
}
}
return(View());
}
public ActionResult ReceiveImage(SendDetails send)
{
watchReceive = new Stopwatch();
watchReceive.Start();
var crtUser = SessionManager.ReturnSessionObject("User") as UserAccount;
if (crtUser != null)
{
using (CryptoDbContext db = new CryptoDbContext())
{
var image = db.ImageDetails.Find(send.ImageId);
if (image != null)
{
var parameters = this.GetEncryptParameters(image, send.RSAKey);
db.ImageDetails.Remove(image);
db.SaveChanges();
watchReceive.Stop();
ReceiveImageTime = watchReceive.ElapsedMilliseconds;
return(Json(new { Image = image.Image, Parmateres = parameters }));
}
else
{
return(Json(new { Message = "No image" }));
}
}
}
else
{
return(RedirectToAction("Login"));
}
}
public ActionResult ChatOn(int userId)
{
using (CryptoDbContext db = new CryptoDbContext())
{
var user = db.UserAccount.Where(u => u.UserID == userId).FirstOrDefault();
ViewBag.User = user;
return(View());
}
}
public async Task <CryptoCurrency> Get(int id)
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
CryptoCurrency entity = await context.Set <CryptoCurrency>().FirstOrDefaultAsync((e) => e.Id == id);
return(entity);
}
}
public async Task <IEnumerable <CryptoCurrency> > GetAll()
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
IEnumerable <CryptoCurrency> entities = await context.Set <CryptoCurrency>().ToListAsync();
return(entities);
}
}
public async Task <Account> GetByUsername(string username)
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
return(await context.Accounts
.Include(a => a.AccountOwner)
.Include(a => a.CryptoInvestments)
.FirstOrDefaultAsync(a => a.AccountOwner.Username == username));
}
}
public ActionResult Index()
{
using (CryptoDbContext db = new CryptoDbContext())
{
var crtUser = SessionManager.ReturnSessionObject("User") as UserAccount;
List <UserAccount> registeredUsers = new List <UserAccount>();
registeredUsers = db.UserAccount.Where(usr => usr.UserID != crtUser.UserID).ToList();
return(View(registeredUsers));
}
}
public async Task <Account> GetByEmail(string email)
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
return(await context.Accounts
.Include(a => a.AccountOwner)
.Include(a => a.CryptoInvestments)
.FirstOrDefaultAsync(a => a.AccountOwner.Email == email));
}
}
public async Task <T> Create(T entity)
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
EntityEntry <T> createdResult = await context.Set <T>().AddAsync(entity);
await context.SaveChangesAsync();
return(createdResult.Entity);
}
}
public async Task <Account> Get(int id)
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
Account entity = await context.Accounts.Include(a => a.AccountOwner)
.Include(a => a.CryptoInvestments)
.FirstOrDefaultAsync((e) => e.Id == id);
return(entity);
}
}
public async Task <User> GetByUserId(int user)
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
User entity = await context.Users
.Include(a => a.Id)
.FirstOrDefaultAsync((e) => e.Id == user);
return(entity);
}
}
public async Task <CryptoCurrency> Update(int id, CryptoCurrency entity)
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
entity.Id = id;
context.Set <CryptoCurrency>().Update(entity);
await context.SaveChangesAsync();
return(entity);
}
}
public async Task <CryptoCurrency> Create(CryptoCurrency entity)
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
EntityEntry <CryptoCurrency> created = await context.Set <CryptoCurrency>().AddAsync(entity);
await context.SaveChangesAsync();
return(created.Entity);
}
}
public async Task <bool> Delete(int id)
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
CryptoCurrency entity = await context.Set <CryptoCurrency>().FirstOrDefaultAsync((e) => e.Id == id);
context.Set <CryptoCurrency>().Remove(entity);
await context.SaveChangesAsync();
return(true);
}
}
public async Task <IEnumerable <Account> > GetAll()
{
using (CryptoDbContext context = _contextFactory.CreateDbContext())
{
IEnumerable <Account> entities = await context.Accounts
.Include(a => a.AccountOwner)
.Include(a => a.CryptoInvestments)
.ToListAsync();
return(entities);
}
}
public ActionResult ReceiveImage()
{
var crtUser = SessionManager.ReturnSessionObject("User") as UserAccount;
if (crtUser != null)
{
using (CryptoDbContext db = new CryptoDbContext())
{
var images = db.ImageDetails.Where(r => r.ReceiverId == crtUser.UserID.ToString());
if (images != null && images.Any())
{
var imageId = new List <string>();
var senderId = new List <string>();
var senderName = new List <string>();
foreach (var image in images)
{
if (image.Image != null)
{
imageId.Add(image.ImageId.ToString());
senderId.Add(image.SenderId);
var user = db.UserAccount.Where(u => u.UserID.ToString() == image.SenderId).FirstOrDefault();
senderName.Add(user.FirstName + " " + user.LastName);
}
else
{
db.ImageDetails.Remove(image);
}
}
return(Json(new
{
SenderName = senderName,
SenderId = senderId,
ImageId = imageId
}, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new
{
SenderName = String.Empty,
SenderId = String.Empty,
ImageId = String.Empty
}, JsonRequestBehavior.AllowGet));
}
}
}
else
{
return(RedirectToAction("Login"));
}
}
public ActionResult Login(UserAccount user)
{
using (CryptoDbContext db = new CryptoDbContext())
{
var usr = db.UserAccount.Where(u => u.Username == user.Username && u.Password == user.Password).FirstOrDefault();
if (usr != null)
{
SessionManager.RegisterSession("User", usr);
return(RedirectToAction("LoggedIn"));
}
else
{
SessionManager.FreeSession("User");
ModelState.AddModelError("", "Username or password is wrong");
}
}
return(View());
}
public ActionResult Register(UserAccount account)
{
if (ModelState.IsValid)
{
using (CryptoDbContext db = new CryptoDbContext())
{
var usr = db.UserAccount.Where(u => u.Username == account.Username).FirstOrDefault();
if (usr != null)
{
ViewBag.RegisterError = account.Username + " already exists, please choose a different username.";
ModelState.Clear();
return(View());
}
db.UserAccount.Add(account);
db.SaveChanges();
ModelState.Clear();
ViewBag.Message = account.FirstName + " " + account.LastName + " successfully registered!";
}
}
return(View());
}
public TestBase()
{
_context = CryptoDbContextFactory.Create();
}
public TradeDataService(CryptoDbContext context, ILogger logger)
{
_logger = logger;
_context = context;
}
public static void Destroy(CryptoDbContext context)
{
context.Database.EnsureDeleted();
context.Dispose();
}
public CoinService(CryptoDbContext context, ILogger logger)
{
_context = context;
_logger = logger;
}
public CoinsController(CryptoDbContext context, ILogger <CoinsController> logger)
{
_context = context;
_logger = logger;
}
public ApiKeysController(CryptoDbContext context)
{
_context = context;
}
public PreferredCoinController(CryptoDbContext context, ILogger <PreferredCoinController> logger)
{
_context = context;
_logger = logger;
}
public CryptoController(CryptoDbContext context)
{
_context = context;
}
public UserPreferenceService(CryptoDbContext context, ILogger logger)
{
_context = context;
_logger = logger;
}
