/// <summary>
///
/// </summary>
/// <param name="idDeck"></param>
/// <returns></returns>
public static List <Card> GetDeckCardsById(int idDeck)
{
var deckCards = new List <Card>();
try
{
using (var db = new ClonestoneFSEntities())
{
//var dbDeck = db.Decks.Where(d => d.ID_Person == idPerson).FirstOrDefault();
//if (dbDeck == null)
//{
// throw new Exception("UserDoesNotExist");
//}
//var dbDeckCollection = dbDeck.AllDeckcards.ToList();
var dbDeckCards = db.AllDeckcards.Where(d => d.ID_Deck == idDeck);
if (dbDeckCards == null)
{
throw new Exception("CardCollectionNotFound");
}
foreach (var dc in dbDeckCards)
{
deckCards.Add(dc.Card);
}
return(deckCards);
}
}
catch (Exception e)
{
Writer.LogError(e);
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static bool AddDefaultDecksByUserId(int id)
{
Person user = null;
try
{
using (var db = new ClonestoneFSEntities())
{
user = db.AllPersons.Find(id);
bool addedAll = false;
if (user == null)
{
throw new Exception("UserNotFound");
}
for (int i = 1; i <= 3; ++i)
{
//addedAll = AddDeckByUserId(id, user.Email + i.ToString());
addedAll = AddDeckByUserId(id, user.Gamertag + " Deck " + i.ToString());
}
return(addedAll);
}
}
catch (Exception e)
{
Writer.LogError(e);
return(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static int GetNumDeckCardsById(int id)
{
Deck deck = null;
int numCards = -1;
try
{
using (var db = new ClonestoneFSEntities())
{
deck = db.AllDecks.Find(id);
if (deck == null)
{
throw new Exception("DeckNotFound");
}
numCards = deck.AllDeckcards.Count;
return(numCards);
}
}
catch (Exception e)
{
Writer.LogError(e);
return(numCards);
}
}
public static bool Register(Person regUser)
{
try
{
using (var db = new ClonestoneFSEntities())
{
if (db.AllPersons.Any(n => n.Email == regUser.Email))
{
throw new Exception("UserAlreadyExists");
}
//Salt erzeugen
string salt = Helper.GenerateSalt();
//Passwort Hashen
string hashedAndSaltedPassword = Helper.GenerateHash(regUser.Password + salt);
regUser.Password = hashedAndSaltedPassword;
regUser.Salt = salt;
db.AllPersons.Add(regUser);
db.SaveChanges();
}
}
catch (Exception e)
{
Writer.LogError(e);
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public static List <Deck> GetAllDecksByEmail(string email)
{
try
{
using (var db = new ClonestoneFSEntities())
{
var dbUser = db.AllPersons.Where(u => u.Email == email).FirstOrDefault();
if (dbUser == null)
{
throw new Exception("UserDoesNotExist");
}
var dbDecks = dbUser.AllDecks.ToList();
if (dbDecks == null)
{
throw new Exception("NoDecksFound");
}
return(dbDecks);
}
}
catch (Exception e)
{
Writer.LogError(e);
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public static List <Card> GetAllCardsByEmail(string email)
{
var cardList = new List <Card>();
try
{
using (var db = new ClonestoneFSEntities())
{
var user = db.AllPersons.Where(u => u.Email == email).FirstOrDefault();
if (user == null)
{
throw new Exception("UserDoesNotExist");
}
var userPersonCards = user.AllPersonCards.ToList();
if (userPersonCards == null)
{
throw new Exception("CardCollectionNotFound");
}
cardList = userPersonCards.Select(x => x.Card).ToList();
return(cardList);
}
}
catch (Exception e)
{
Writer.LogError(e);
return(null);
}
}
/// <summary>
/// Alle PACK aus der Tabelle PACK ohne PARAMETER
/// </summary>
/// <returns>return allPacks</returns>
public static List <Pack> AllCardPacks()
{
List <Pack> allPacks = null;
//var allPacks = new List<Pack>();
try
{
using (var db = new ClonestoneFSEntities())
{
//allPacks = db.Packs.OrderBy(x => x.Cardquantity).ToList();
allPacks = db.AllPacks.ToList();
}
if (allPacks == null)
{
throw new Exception("kein Pack gefunden");
}
}
catch (Exception e)
{
Writer.LogError(e);
Debugger.Break();
}
return(allPacks);
}
/// <summary>
/// Drop current Deck based on DeckID to save it anew, used for the Deckbuilder
/// </summary>
/// <param name="deckId"></param>
public static void DropDeck(int deckId)
{
using (var db = new ClonestoneFSEntities())
{
db.pClearDeckByID(deckId);
db.SaveChanges();
}
}
/// Karten FÜR das Deck
public static List <Card> GetAllCardsForDeck(string email, int idDeck)
{
List <PersonCard> personCards = null;
try
{
using (var context = new ClonestoneFSEntities())
{
var person = context.AllPersons
.Include(x => x.AllPersonCards)
.Include(x => x.AllPersonCards.Select(y => y.Card))
.FirstOrDefault(x => x.Email.Equals(email));
if (person == null)
{
throw new ArgumentException("Invalid username");
}
/// get ALL cards assigned to this user
personCards = person.AllPersonCards.ToList();
/// get deck for given idDeck
Deck deck = context.AllDecks.FirstOrDefault(x => x.ID == idDeck);
if (deck == null)
{
throw new ArgumentException("Invalid idDeck");
}
/// iterate over all userCards
foreach (var userCard in personCards)
{
/// check if current userCard is already present in current deck
DeckCard deckCard = deck.AllDeckcards.FirstOrDefault(x => x.ID_Card == userCard.ID_Card);
/// if card is already in deck
if (deckCard != null)
{
/// decrease number of cards available
userCard.NumberOfCards -= deckCard.NumCards;
}
}
/// return only those cards, whose number is greater than 0
personCards = personCards.Where(x => x.NumberOfCards > 0).ToList();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debugger.Break();
throw ex;
}
return(personCards.Select(x => x.Card).ToList());
}
/// <summary>
/// Get all Users
/// </summary>
/// <returns></returns>
public static List <tblperson> GetAllUser()
{
List <tblperson> ReturnList = null;
using (var db = new ClonestoneFSEntities())
{
ReturnList = db.tblperson.ToList();
}
return(ReturnList);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
//Theoretisch überflüssig
public static string GetCardTypeById(int?id)
{
string TypeName = "n/a";
using (var db = new ClonestoneFSEntities())
{
TypeName = db.AllTypes.Find(id).Name;
}
return(TypeName);
}
public static int GetMostBuyedPacks()
{
int mostBuyedPacks = -1;
using (var db = new ClonestoneFSEntities())
{
mostBuyedPacks = db.AllOrders.Count();
}
return(mostBuyedPacks);
}
/// <summary>
/// Get all sold Packs based on UserID
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public static List <vSoldPacks> GetAllSoldPacksFromUserId(int userId)
{
List <vSoldPacks> SoldPacks = new List <vSoldPacks>();
using (var db = new ClonestoneFSEntities())
{
SoldPacks = db.vSoldPacks.Where(p => p.fkperson == userId).ToList();
}
return(SoldPacks);
}
/// <summary>
/// Get all sold Packs
/// </summary>
/// <returns></returns>
public static List <vSoldPacks> GetAllSoldPacks()
{
List <vSoldPacks> SoldPacks = new List <vSoldPacks>();
using (var db = new ClonestoneFSEntities())
{
SoldPacks = db.vSoldPacks.ToList();
}
return(SoldPacks);
}
/// <summary>
/// Get Deckcards based on UserID and DeckID
/// </summary>
/// <param name="DeckID"></param>
/// <returns></returns>
public static List <tblcollection> GetAllDeckCards(int DeckID)
{
List <tblcollection> ReturnDeckCards = null;
using (var db = new ClonestoneFSEntities())
{
ReturnDeckCards = db.tblcollection.Include(y => y.tblcard).Where(d => d.tbldeck.Any(e => e.iddeck == DeckID)).ToList();
}
return(ReturnDeckCards);
}
public ActionResult DeleteConfirmed(int id)
{
ClonestoneFSEntities db = new ClonestoneFSEntities();
Person p = db.AllPersons.Find(id);
db.AllPersons.Remove(p);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Get 1 User based on an ID
/// </summary>
/// <param name="id"></param>
/// <returns>tblPerson</returns>
public static tblperson GetUserByIdAdmin(int id)
{
tblperson ReturnUser = null;
using (var db = new ClonestoneFSEntities())
{
ReturnUser = db.tblperson.Where(u => u.idperson == id).FirstOrDefault();
}
return(ReturnUser);
}
/// <summary>
/// Get all Decks
/// </summary>
/// <returns></returns>
public static List <tbldeck> GetAllDecks()
{
List <tbldeck> ReturnDeckList = null;
using (var db = new ClonestoneFSEntities())
{
ReturnDeckList = db.tbldeck.ToList();
}
return(ReturnDeckList);
}
/// <summary>
/// LAP Methode für STATISTIK
/// Methode um aus Datenbank alle PACKS zu ermitteln
/// </summary>
/// <returns>numPacks</returns>
public static int GetNumPacks()
{
int numPacks = -1;
using (var db = new ClonestoneFSEntities())
{
numPacks = db.AllPacks.Count();
}
return(numPacks);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static List <Card> GetAllCards()
{
List <Card> ReturnList = null;
using (var db = new ClonestoneFSEntities())
{
//ReturnList = db.tblcard.Include(t => t.tbltype).ToList();
ReturnList = db.AllCards.ToList();
}
return(ReturnList);
}
/// <summary>
/// Get Deck name based on DeckID, used for the Deckbuilder
/// </summary>
/// <param name="DeckID"></param>
/// <returns></returns>
public static string GetDecknameById(int DeckID)
{
using (var db = new ClonestoneFSEntities())
{
var Deckname = (from d in db.tbldeck
where d.iddeck == DeckID
select d.deckname).FirstOrDefault().ToString();
return(Deckname);
}
}
/// <summary>
/// Get only Goldpacks
/// </summary>
/// <returns></returns>
public static List <tblpack> GetGoldPacks()
{
List <tblpack> ReturnList = null;
using (var db = new ClonestoneFSEntities())
{
ReturnList = (from p in db.tblpack
where p.goldquantity > 0
select p).ToList();
}
return(ReturnList);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static List <Person> GetAllUser()
{
List <Person> personList = null;
using (var db = new ClonestoneFSEntities())
{
// TODO - Include
// .Include(t => t.tabelle) um einen Join zu machen !
personList = db.AllPersons.ToList();
}
return(personList);
}
/// <summary>
/// Get Cardcollection based on UserID, used for the Deckbuilder
/// </summary>
/// <param name="UserID"></param>
/// <returns></returns>
public static List <vCollectionCards> GetAllCollectionCards(int UserID)
{
List <vCollectionCards> ReturnCollectionCards = null;
using (var db = new ClonestoneFSEntities())
{
ReturnCollectionCards = (from c in db.vCollectionCards
where c.fkperson == UserID
select c).ToList();
}
return(ReturnCollectionCards);
}
/// <summary>
/// Get Decks based on UserID
/// </summary>
/// <param name="UserID"></param>
/// <returns></returns>
public static List <tbldeck> GetAllDecksFromUser(int UserID)
{
List <tbldeck> ReturnDeckList = null;
using (var db = new ClonestoneFSEntities())
{
ReturnDeckList = (from d in db.tbldeck
where d.fkperson == UserID
select d).ToList();
}
return(ReturnDeckList);
}
/// <summary>
/// Get Number od Decks
/// </summary>
/// <returns></returns>
public static int GetNumDecks()
{
int numDecks = -1;
using (var db = new ClonestoneFSEntities())
{
numDecks = db.tbldeck.Count();
}
Writer.LogInfo("GetNumDecks " + numDecks);
return(numDecks);
}
/// <summary>
/// Get number of Users
/// </summary>
/// <returns></returns>
public static int GetNumUsers()
{
int numUsers = -1;
using (var db = new ClonestoneFSEntities())
{
numUsers = db.tblperson.Count();
}
Writer.LogInfo("GetNumUsers " + numUsers);
return(numUsers);
}
public static int GetNumCards()
{
int numCards = -1;
using (var db = new ClonestoneFSEntities())
{
numCards = db.AllCards.Count();
}
Writer.LogInfo("GetNumCards " + numCards);
return(numCards);
}
/// <summary>
///
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public static int GetNumDecksOwnedByEmail(string email)
{
int numDecks = -1;
using (var db = new ClonestoneFSEntities())
{
Person dbUser = db.AllPersons.Where(u => u.Email == email).FirstOrDefault();
if (dbUser == null)
{
throw new Exception("User exestiert nicht");
}
numDecks = dbUser.AllDecks.Count;
}
return(numDecks);
}
public static int GetNumDistinctCardsOwnedByEmail(string email)
{
int numCards = -1;
using (var db = new ClonestoneFSEntities())
{
Person dbUser = db.AllPersons.Where(u => u.Email == email).FirstOrDefault();
if (dbUser == null)
{
throw new Exception("UserDoesNotExist");
}
numCards = dbUser.AllPersonCards.Count;
}
return(numCards);
}
