public static IQueryable <SpecialOffer> CurrentSpecialOffers(IFunctionalContainer container)
{
return(from obj in container.Instances <SpecialOffer>()
where obj.StartDate <= DateTime.Now &&
obj.EndDate >= new DateTime(2004, 6, 1)
select obj);
}
public static SpecialOfferProduct AssociateSpecialOfferWithProduct
([ContributedAction("Special Offers")] SpecialOffer offer,
[ContributedAction("Special Offers")] Product product,
IFunctionalContainer container)
{
//First check if association already exists
IQueryable <SpecialOfferProduct> query = from sop in container.Instances <SpecialOfferProduct>()
where sop.SpecialOfferID == offer.SpecialOfferID &&
sop.ProductID == product.ProductID
select sop;
if (query.Count() != 0)
{
var t = Container.NewTitleBuilder();
t.Append(offer).Append(" is already associated with").Append(product);
WarnUser(t.ToString());
return(null);
}
var newSop = new SpecialOfferProduct();
newSop.SpecialOffer = offer;
newSop.Product = product;
//product.SpecialOfferProduct.Add(newSop);
Persist(ref newSop);
return(newSop);
}
//To test a ViewModelEdit
public EmailTemplate CreateEmail(IFunctionalContainer container)
{
var email = ViewModelHelper.NewViewModel <EmailTemplate>(container);
email.Status = EmailStatus.New;
return(email);
}
public StoreSalesInfo ReviewSalesResponsibility(IFunctionalContainer container)
{
var ssi = ViewModelHelper.NewViewModel <StoreSalesInfo>(container);
ssi.PopulateUsingKeys(new string[] { AccountNumber, false.ToString() }, container);
return(ssi);
}
public static QueryResultList FindEmployeeByName(
[Optionally] string firstName,
string lastName,
IFunctionalContainer container)
{
return(new QueryResultList(QueryEmployeesByName(firstName, lastName, container)));
}
public SalesOrderHeader NewOrder(IFunctionalContainer container)
{
var order = OrderContributedActions.CreateNewOrder(Root, true, container);
Container.Persist(ref order);
return(order);
}
//This method is to test use of nullable booleans
public static QueryResultList ListEmployees(bool?current, //mandatory
[Optionally] bool?married,
[DefaultValue(false)] bool?salaried,
[Optionally][DefaultValue(true)] bool?olderThan50,
IFunctionalContainer container)
{
var emps = container.Instances <Employee>();
emps = emps.Where(e => e.Current == current.Value);
if (married != null)
{
string value = married.Value ? "M" : "S";
emps = emps.Where(e => e.MaritalStatus == value);
}
emps = emps.Where(e => e.Salaried == salaried.Value);
if (olderThan50 != null)
{
var date = DateTime.Today.AddYears(-50); //Not an exact calculation!
if (olderThan50.Value)
{
emps = emps.Where(e => e.DateOfBirth != null && e.DateOfBirth < date);
}
else
{
emps = emps.Where(e => e.DateOfBirth != null && e.DateOfBirth > date);
}
}
return(new QueryResultList(emps));
}
public static IList <ProductSubcategory> Default0ListProductsBySubCategories(IFunctionalContainer container)
{
return(new List <ProductSubcategory> {
container.Instances <ProductSubcategory>().Single(psc => psc.Name == "Mountain Bikes"),
container.Instances <ProductSubcategory>().Single(psc => psc.Name == "Touring Bikes")
});
}
public static SalesOrderHeader CreateNewOrder([ContributedAction(subMenu)] Customer customer,
[Optionally] bool copyHeaderFromLastOrder,
IFunctionalContainer container)
{
var newOrder = new SalesOrderHeader();
newOrder.Customer = customer;
if (copyHeaderFromLastOrder)
{
SalesOrderHeader last = QueryLastOrder(customer, container).FirstOrDefault();
if (last != null)
{
newOrder.BillingAddress = last.BillingAddress;
newOrder.ShippingAddress = last.ShippingAddress;
newOrder.CreditCard = last.CreditCard;
newOrder.ShipMethod = last.ShipMethod;
newOrder.AccountNumber = last.AccountNumber;
}
}
else
{
newOrder.BillingAddress = PersonRepository.AddressesFor(customer.BusinessEntity(), container, "Billing").FirstOrDefault();
newOrder.ShippingAddress = PersonRepository.AddressesFor(customer.BusinessEntity(), container, "Shipping").FirstOrDefault();
}
return(newOrder);
}
public static IQueryable <Vendor> AllVendorsWithWebAddresses(IFunctionalContainer container)
{
return(from obj in container.Instances <Vendor>()
where obj.PurchasingWebServiceURL != null
orderby obj.Name
select obj);
}
public static SalesOrderHeader CheckOut(IFunctionalContainer container)
{
var cust = GetCustomerForUser();
var order = OrderContributedActions.CreateNewOrder(cust, true, container);
order.AddItemsFromCart = true;
return(order);
}
public static IQueryable <ShoppingCartItem> Cart(IFunctionalContainer container)
{
string id = GetShoppingCartIDForUser();
return(from sci in container.Instances <ShoppingCartItem>()
where sci.ShoppingCartID == id
select sci);
}
//This method is to test use of non-nullable booleans
public static QueryResultList ListEmployees2(bool current,
[Optionally] bool married,
[DefaultValue(false)] bool salaried,
[DefaultValue(true)] bool olderThan50,
IFunctionalContainer container)
{
return(ListEmployees(current, married, salaried, olderThan50, container));
}
public void Persisted(IFunctionalContainer container)
{
if (AddItemsFromCart)
{
ShoppingCartRepository.AddAllItemsInCartToOrder(this, container);
AddItemsFromCart = false;
}
}
public static SpecialOffer NoDiscount(IFunctionalContainer container)
{
IQueryable <SpecialOffer> query = from obj in container.Instances <SpecialOffer>()
where obj.SpecialOfferID == 1
select obj;
return(query.FirstOrDefault());
}
public void PopulateUsingKeys(string[] instanceId, IFunctionalContainer container)
{
int p = int.Parse(instanceId.First());
short n = short.Parse(instanceId.Skip(1).First());
Product = container.Instances <Product>().Single(c => c.ProductID == p);
Number = n;
}
public static QueryResultSingle FindProductByNumber(string number, IFunctionalContainer container)
{
IQueryable <Product> query = from obj in container.Instances <Product>()
where obj.ProductNumber == number
select obj;
return(SingleObjectWarnIfNoMatch(query));
}
public IQueryable <ShoppingCartItem> RemoveItems(
IEnumerable <ShoppingCartItem> items,
IFunctionalContainer container
)
{
ShoppingCartRepository.RemoveItems(items);
return(ShoppingCartRepository.Cart(container));
}
public static List <Customer> RandomCustomers(IFunctionalContainer container)
{
var list = new List <Customer>();
list.Add(RandomIndividual(container));
list.Add(RandomStore(container));
return(list);
}
internal static Person RandomPerson(IFunctionalContainer container)
{
//TODO: Provide proper Function implementation of Random
int random = new Random().Next(container.Instances <Person>().Count());
//The OrderBy(...) doesn't do anything, but is a necessary precursor to using .Skip
//which in turn is needed because LINQ to Entities doesn't support .ElementAt(x)
return(container.Instances <Person>().OrderBy(n => "").Skip(random).FirstOrDefault());
}
#pragma warning restore 612,618
public void AddNewDetails(
Product product,
[DefaultValue((short)1)] short quantity,
IFunctionalContainer container)
{
var detail = AddNewDetail(product, quantity, container);
Container.Persist(ref detail);
}
public void AddNewSalesReasonsByCategories(
IEnumerable <SalesReasonCategories> reasonCategories,
IFunctionalContainer container)
{
foreach (SalesReasonCategories rc in reasonCategories)
{
AddNewSalesReasonsByCategory(rc, container);
}
}
/// <summary>
/// Returns a random instance from the set of all instance of type T
/// </summary>
protected static QueryResultSingle Random <T>(IFunctionalContainer container) where T : class
{
IQueryable <T> query = container.Instances <T>();
int random = new Random().Next(query.Count());
//The OrderBy(...) doesn't do anything, but is a necessary precursor to using .Skip
//which in turn is needed because LINQ to Entities doesn't support .ElementAt(x)
return(new QueryResultSingle(query.OrderBy(n => "").Skip(random).FirstOrDefault()));
}
public static Customer RandomIndividual(IFunctionalContainer container)
{
var allIndividuals = IndividualCustomers(container);
int random = new Random().Next(allIndividuals.Count());
//The OrderBy(...) doesn't do anything, but is a necessary precursor to using .Skip
//which in turn is needed because LINQ to Entities doesn't support .ElementAt(x)
return(allIndividuals.OrderBy(n => "").Skip(random).FirstOrDefault());
}
public virtual bool HideLoginID(IFunctionalContainer container)
{
if (Container.IsPersistent(this))
{
Employee userAsEmployee = EmployeeRepository.CurrentUserAsEmployee(container);
return(userAsEmployee != null ? userAsEmployee.LoginID != LoginID : true);
}
return(false);
}
public IQueryable <Employee> ColleaguesInSameDept(
IFunctionalContainer container)
{
var allCurrent = container.Instances <EmployeeDepartmentHistory>().Where(edh => edh.EndDate == null);
var thisId = this.BusinessEntityID;
var thisDeptId = allCurrent.Single(edh => edh.EmployeeID == thisId).DepartmentID;
return(allCurrent.Where(edh => edh.DepartmentID == thisDeptId).Select(edh => edh.Employee));
}
public StoreSalesInfo Save(IFunctionalContainer container)
{
EditMode = false;
var cus = CustomerRepository.QueryCustomerByAccountNumber(AccountNumber, container).First();
cus.SalesTerritory = SalesTerritory;
cus.Store.SalesPerson = SalesPerson;
cus.Store.Name = StoreName;
return(this);
}
public static QueryResultSingle CreateStaffSummary(IFunctionalContainer container)
{
var emps = container.Instances <Employee>();
var sum = new StaffSummary();
sum.TotalStaff = emps.Count();
sum.Male = emps.Count(e => e.Gender == "M");
sum.Female = emps.Count(e => e.Gender == "F");
return(new QueryResultSingle(sum));
}
public static CustomerDashboard CustomerDashboard(
string accountNumber,
IFunctionalContainer container)
{
Customer cust = QueryCustomerByAccountNumber(accountNumber, container).FirstOrDefault();
var dash = ViewModelHelper.NewViewModel <CustomerDashboard>(container);
dash.Root = cust;
return(dash);
}
public static QueryResultSingle FindEmployeeByNationalIDNumber(
string nationalIDNumber,
IFunctionalContainer container)
{
IQueryable <Employee> query = from obj in container.Instances <Employee>()
where obj.NationalIDNumber == nationalIDNumber
select obj;
return(SingleObjectWarnIfNoMatch(query));
}
