/// <summary>
/// The Fetch method will find the record in the database, and return a newly instantiated object containing
/// the record data. It uses the generic DataSQL Fetch method to dynamically instantiate the object using Reflection,
/// which will return the instance.
/// </summary>
/// <param name="id">The primary key of the object desired to find.</param>
/// <returns>The instance object.</returns>
public static Transaction Fetch(int id)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@TransactionID", id);
return(DataSQL <Transaction> .Fetch(SQL_FETCH, parameters));
}
/// <summary>
/// The Add method is used to insert the received object into the corresponding database table. It uses the
/// AddParameters method to covert the object attributes into a dictionary, which is then passed
/// into the DataSQL helper method along with the insert sql statement.
/// </summary>
/// <param name="customer">The customer object.</param>
/// <returns>The inserted record's primary key.</returns>
public static int Add(Customer customer)
{
// Converts the instance data to a dictionary, and passes both the sql statement & the dictionary
// as arguments to the generic ScalarQuery helper method. It will return a int being the newly inserted
// primary key.
return(DataSQL <Customer> .ScalarQuery(SQL_INSERT, AddParameters(customer)));
}
/// <summary>
/// The List method is used to fetch all objects within the corresponding database table. It uses
/// the generic List method of the DataSQL class to fetch the instances. It uses Reflection to dynamically
/// instantiate the object based on the generic type.
/// </summary>
/// <param name="id">The Customer primary key.</param>
/// <returns>Returns a List of the transactions relating to a Customer.</returns>
public static List <Transaction> List(int customerID)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@CustomerID", customerID);
return(DataSQL <Transaction> .List(SQL_LIST_CUSTOMER, parameters));
}
/// <summary>
/// The Update method is used to update the record within the database table to the instance
/// data of the received object. The AddParameters method is used to covert the instance data
/// into a passable dictionary of data, which is then passed to the generic helper method of
/// the DataSQL class along with the statement. The ID is also added at the end of the dictionary,
/// since it is the last variable (within the where clause) of the update statement.
/// </summary>
/// <param name="dvd">The dvd object.</param>
/// <returns>A int indicating the rows affected.</returns>
public static int Update(DVD dvd)
{
Dictionary <string, object> parameters = AddParameters(dvd);
parameters.Add("@dvdID", dvd.dvdID);
return(DataSQL <DVD> .NonQuery(SQL_UPDATE, parameters));
}
/// <summary>
/// The List method is used to fetch all objects within the corresponding database table. It uses
/// the generic List method of the DataSQL class to fetch the instances. It uses Reflection to dynamically
/// instantiate the object based on the generic type.
/// </summary>
/// <param name="id">The DVD primary key.</param>
/// <returns>Returns a List of the DVD Copies.</returns>
public static List <DVDCopy> List(int dvdID)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@dvdID", dvdID);
return(DataSQL <DVDCopy> .List(SQL_LIST, parameters));
}
/// <summary>
/// The Fetch method will find the record in the database, and return a newly instantiated object containing
/// the record data. It uses the generic DataSQL Fetch method to dynamically instantiate the object using Reflection,
/// which will return the instance.
/// </summary>
/// <param name="id">The primary key of the object desired to find.</param>
/// <returns>The instance object.</returns>
public static CreditCard Fetch(int id)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@CardID", id);
return(DataSQL <CreditCard> .Fetch(SQL_FETCH, parameters));
}
/// <summary>
/// The Fetch method will find the record in the database, and return a newly instantiated object containing
/// the record data. It uses the generic DataSQL Fetch method to dynamically instantiate the object using Reflection,
/// which will return the instance.
/// </summary>
/// <param name="id">The primary key of the object desired to find.</param>
/// <returns>The instance object.</returns>
public static DVD Fetch(int id)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@dvdID", id);
return(DataSQL <DVD> .Fetch(SQL_FETCH, parameters));
}
/// <summary>
/// The Clear method is used to delete all record from the corresponding database table. It receives
/// the primary key of the transaction, and will use the generic helper method of the DataSQL class to remove all the child records.
/// </summary>
/// <param name="id">The transaction primary key.</param>
public static void Clear(int id)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@TransactionID", id);
DataSQL <TransactionItem> .NonQuery(SQL_DELETE, parameters);
}
/// <summary>
/// The Remove method is used to delete a record from the corresponding database table. It receives
/// the primary key, and will use the generic helper method of the DataSQL class to remove the record.
/// </summary>
/// <param name="id">The primary key.</param>
/// <returns>A boolean indicating whether the record was removed.</returns>
public static Boolean Remove(int id)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@CardID", id);
return(DataSQL <CreditCard> .NonQuery(SQL_DELETE, parameters) > 0);
}
/// <summary>
/// The Update method is used to update the record within the database table to the instance
/// data of the received object. The AddParameters method is used to covert the instance data
/// into a passable dictionary of data, which is then passed to the generic helper method of
/// the DataSQL class along with the statement. The ID is also added at the end of the dictionary,
/// since it is the last variable (within the where clause) of the update statement.
/// </summary>
/// <param name="customer">The customer object.</param>
/// <returns>A int indicating the rows affected.</returns>
public static int Update(Transaction transaction)
{
Dictionary <string, object> parameters = AddParameters(transaction);
parameters.Add("@TransactionID", transaction.transactionID);
return(DataSQL <Transaction> .NonQuery(SQL_UPDATE, parameters));
}
/// <summary>
/// The List method is used to fetch all objects within the corresponding database table. It uses
/// the generic List method of the DataSQL class to fetch the instances. It uses Reflection to dynamically
/// instantiate the object based on the generic type.
/// </summary>
/// <param name="id">The Customer primary key.</param>
/// <returns>Returns a List of the Credit Cards.</returns>
public static List <CreditCard> List(int customerID)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@CustomerID", customerID);
return(DataSQL <CreditCard> .List(SQL_LIST, parameters));
}
/// <summary>
/// The Fetch method will find the record in the database, and return a newly instantiated object containing
/// the record data. It uses the generic DataSQL Fetch method to dynamically instantiate the object using Reflection,
/// which will return the instance.
/// </summary>
/// <param name="transactionID">The Transaction primary key.</param>
/// /// <param name="copyID">The DVD Copy primary key.</param>
/// <returns>The instance object.</returns>
public static TransactionItem Fetch(int transactionID, int copyID)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@TransactionID", transactionID);
parameters.Add("@CopyID", copyID);
return(DataSQL <TransactionItem> .Fetch(SQL_FETCH, parameters));
}
/// <summary>
/// The UpdateCopies method is used to update the status of all the DVDCopies that
/// were added to a transaction. It uses the generic helper method of the DataSQL class
/// to execute the query.
/// </summary>
/// <param name="transactionID">The transactionID of the.</param>
/// <returns>A boolean indicating whether the record was updated.</returns>
public static int UpdateCopies(int transactionID, DVDCopy.Status status)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@Status", (int)status);
parameters.Add("@TransactionID", transactionID);
return(DataSQL <DVDCopy> .NonQuery(SQL_UPDATE, parameters));
}
/// <summary>
/// The Count method is used to count the amount of transaction items that have been
/// added to a specific transaction based on the transaction type (either being rental or sale).
/// </summary>
/// <param name="transactionID">The transaction's primary key.</param>
/// <param name="TransactionType">The transaction type.</param>
/// <returns>The count of items relating to a transaction & type.</returns>
public static int Count(int transactionID, TransactionItem.TransactionType type)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@TransactionID", transactionID);
parameters.Add("@Type", (int)type);
return(DataSQL <Transaction> .ScalarQuery(SQL_COUNT, parameters));
}
/// <summary>
/// The Add method is used to insert the received object into the corresponding database table.
/// It coverts the object attributes into a dictionary, which is then passed
/// into the DataSQL helper method along with the insert sql statement.
/// </summary>
/// <param name="copy">The transaction item object.</param>
public static void Add(TransactionItem item)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@TransactionID", item.transactionID);
parameters.Add("@CopyID", item.copyID);
parameters.Add("@Type", (int)item.type);
DataSQL <TransactionItem> .NonQuery(SQL_INSERT, parameters);
}
/// <summary>
/// The Update method is used to update the record within the database table to the instance
/// data of the received object. It then coverts the instance data
/// into a passable dictionary of data, which is then passed to the generic helper method of
/// the DataSQL class along with the statement. The ID is also added at the end of the dictionary,
/// since it is the last variable (within the where clause) of the update statement.
/// </summary>
/// <param name="card">The credit card object.</param>
/// <returns>A int indicating the rows affected.</returns>
public static int Update(CreditCard card)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@CardHolder", card.cardName);
parameters.Add("@CardNumber", card.cardNumber);
parameters.Add("@CardID", card.cardID);
return(DataSQL <CreditCard> .NonQuery(SQL_UPDATE, parameters));
}
/// <summary>
/// The Add method is used to insert the received object into the corresponding database table.
/// It coverts the object attributes into a dictionary, which is then passed
/// into the DataSQL helper method along with the insert sql statement.
/// </summary>
/// <param name="card">The credit card object.</param>
/// <returns>The rows affected.</returns>
public static int Add(CreditCard card)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@CustomerID", card.customerID);
parameters.Add("@CardHolder", card.cardName);
parameters.Add("@CardNumber", card.cardNumber);
return(DataSQL <CreditCard> .NonQuery(SQL_INSERT, parameters));
}
/// <summary>
/// The Add method is used to insert the received object into the corresponding database table.
/// It coverts the object attributes into a dictionary, which is then passed
/// into the DataSQL helper method along with the insert sql statement.
/// </summary>
/// <param name="copy">The dvd copy object.</param>
/// <returns>A boolean indicating whether the record was inserted.</returns>
public static Boolean Add(DVDCopy copy)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@dvdID", copy.dvdID);
parameters.Add("@Barcode", copy.barcode);
parameters.Add("@Status", (int)copy.status);
return(DataSQL <DVDCopy> .NonQuery(SQL_INSERT, parameters) > 0);
}
/// <summary>
/// The Update method is used to update the record within the database table to the instance
/// data of the received object. It then coverts the instance data
/// into a passable dictionary of data, which is then passed to the generic helper method of
/// the DataSQL class along with the statement. The ID is also added at the end of the dictionary,
/// since it is the last variable (within the where clause) of the update statement.
/// </summary>
/// <param name="copy">The dvd copy object.</param>
/// <returns>A boolean indicating whether the record was updated.</returns>
public static Boolean Update(DVDCopy copy)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@Barcode", copy.barcode);
parameters.Add("@Status", (int)copy.status);
parameters.Add("@copyID", copy.copyID);
return(DataSQL <DVDCopy> .NonQuery(SQL_UPDATE, parameters) > 0);
}
/// <summary>
/// The Remove method is used to delete a record from the corresponding database table. It receives
/// the primary key, and will use the generic helper method of the DataSQL class to remove the record.
/// </summary>
/// <param name="id">The primary key.</param>
/// <returns>A boolean indicating whether the record was removed.</returns>
public static Boolean Remove(int id)
{
// Instantiates a new dictionary to add the parameters.
Dictionary <string, object> parameters = new Dictionary <string, object>();
// Adds the primary key as a parameter.
parameters.Add("@CustomerID", id);
// Invokes the generic NonQuery method passing the sql statement, and the paramaters as arguments.
// Returns a boolean indicating success.
return(DataSQL <Customer> .NonQuery(SQL_DELETE, parameters) > 0);
}
/// <summary>
/// The Fetch method will find the record in the database, and return a newly instantiated object containing
/// the record data. It uses the generic DataSQL Fetch method to dynamically instantiate the object using Reflection,
/// which will return the instance.
/// </summary>
/// <param name="id">The primary key of the object desired to find.</param>
/// <returns>The instance object.</returns>
public static Customer Fetch(int id)
{
// Instantiates a new dictionary to add the parameters.
Dictionary <string, object> parameters = new Dictionary <string, object>();
// Adds the primary key as a parameter.
parameters.Add("@CustomerID", id);
// Invokes the generic Fetch method passing the sql statement, and the paramaters as arguments.
// Returns the object instance.
return(DataSQL <Customer> .Fetch(SQL_FETCH, parameters));
}
/// <summary>
/// The Update method is used to update the record within the database table to the instance
/// data of the received object. The AddParameters method is used to covert the instance data
/// into a passable dictionary of data, which is then passed to the generic helper method of
/// the DataSQL class along with the statement. The ID is also added at the end of the dictionary,
/// since it is the last variable (within the where clause) of the update statement.
/// </summary>
/// <param name="customer">The customer object.</param>
/// <returns>A int indicating the rows affected.</returns>
public static int Update(Customer customer)
{
// Converts the instance data to a dictionary which matches the variables in the sql statement.
Dictionary <string, object> parameters = AddParameters(customer);
// Adds the primary key to the end, which is for the where clause.
parameters.Add("@CustomerID", customer.customerID);
// Passes both the SQL statement, and the parameters as arguments to the generic NonQuery
// helper method. It will return a int of the rows affected by the change.
return(DataSQL <Customer> .NonQuery(SQL_UPDATE, parameters));
}
/// <summary>
/// The List method is used to fetch all objects within the corresponding database table. It uses
/// the generic List method of the DataSQL class to fetch the instances. It uses Reflection to dynamically
/// instantiate the object based on the generic type. It doesn't however return a List of TransactionItem,
/// instead it will return the DVDCopy objects relating to the Item.
/// </summary>
/// <param name="transactionID">The Transaction primary key.</param>
/// <param name="TransactionType">The Transaction Type.</param>
/// <returns>Returns a List of the DVD Copies.</returns>
public static List <DVDCopy> List(int transactionID, TransactionItem.TransactionType type)
{
// Instantiates a empty list of DVDCopy.
List <DVDCopy> list = new List <DVDCopy>();
// Prepares and adds the paramaters to the dictionary.
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@TransactionID", transactionID);
parameters.Add("@Type", (int)type);
// Executes the query through the helper, then iterates the resulting TransactionItems.
foreach (TransactionItem item in DataSQL <TransactionItem> .List(SQL_LIST, parameters))
{
// Adds each item's relating DVDCopy instance to the DVD Copy list.
list.Add(item.copy);
}
return(list); // Returns the List.
}
/// <summary>
/// The Add method is used to insert the received object into the corresponding database table. It uses the
/// AddParameters method to covert the object attributes into a dictionary, which is then passed
/// into the DataSQL helper method along with the insert sql statement.
/// </summary>
/// <param name="dvd">The dvd object.</param>
/// <returns>The inserted record's primary key.</returns>
public static int Add(DVD dvd)
{
return(DataSQL <DVD> .ScalarQuery(SQL_INSERT, AddParameters(dvd)));
}
/// <summary>
/// The List method is used to fetch all objects within the corresponding database table. It uses
/// the generic List method of the DataSQL class to fetch the instances. It uses Reflection to dynamically
/// instantiate the object based on the generic type.
/// </summary>
/// <returns>Returns a List of the objects.</returns>
public static List <DVD> List()
{
return(DataSQL <DVD> .List(SQL_LIST, null));
}
/// <summary>
/// The List method is used to fetch all objects within the corresponding database table. It uses
/// the generic List method of the DataSQL class to fetch the instances. It uses Reflection to dynamically
/// instantiate the object based on the generic type.
/// </summary>
/// <returns>Returns a List of the objects.</returns>
public static List <Transaction> List()
{
return(DataSQL <Transaction> .List(SQL_LIST, null));
}
/// <summary>
/// The List method is used to fetch all objects within the corresponding database table. It uses
/// the generic List method of the DataSQL class to fetch the instances. It uses Reflection to dynamically
/// instantiate the object based on the generic type.
/// </summary>
/// <returns>Returns a List of the objects.</returns>
public static List <Customer> List()
{
return(DataSQL <Customer> .List(SQL_LIST, null));
}
/// <summary>
/// The Add method is used to insert the received object into the corresponding database table. It uses the
/// AddParameters method to covert the object attributes into a dictionary, which is then passed
/// into the DataSQL helper method along with the insert sql statement.
/// </summary>
/// <param name="transaction">The transaction object.</param>
/// <returns>The inserted record's primary key.</returns>
public static int Add(Transaction transaction)
{
return(DataSQL <Transaction> .ScalarQuery(SQL_INSERT, AddParameters(transaction)));
}
