public String AddBooking()
{
String idParam = Request.Params["pcid"];
String useridParam = Request.Params["userid"];
String date = Request.Params["date"];
String time = Request.Params["time"];
String duration = Request.Params["duration"];
int pcid = int.Parse(idParam);
int userid = int.Parse(useridParam);
DateTime newDate = DateTime.ParseExact(date + " " + time, "dd/MM/yyyy HH:mm", null);
int intDuration = int.Parse(duration);
OrderService orderService = new OrderService();
OrderStatus orderStatus = orderService.isCanOrder(pcid, newDate, intDuration, userid);
if (orderStatus.status == OrderStatusCode.FAIL)
{
return orderStatus.message;
}
Order order = new Order();
order.PCID = pcid;
order.UserID = userid;
order.StartTime = newDate;
order.Duration = intDuration;
order.OrderStatus = 0;
// tru balance
IRepository<Order> repository = new OrderRepository();
repository.Add(order);
return "true";
}
private void InitOrders(OrderRepository orderRepo, CarRepository carsRepo, LocationRepository locRepo)
{
var date = DateTime.Now;
orderRepo.Add(new Order { CarID = 2, DateStart = date.AddDays(2), DateEnd = date.AddDays(5), PointStartID = 1, PointEndID = 2 });
orderRepo.Add(new Order { CarID = 3, DateStart = date.AddDays(3), DateEnd = date.AddDays(5), PointStartID = 2, PointEndID = 2 });
orderRepo.Add(new Order { CarID = 4, DateStart = date.AddDays(4), DateEnd = date.AddDays(5), PointStartID = 2, PointEndID = 2 });
}
protected void Page_Load(object sender, EventArgs e)
{
var str = Request.Params.AllKeys.Aggregate("", (current, key) => current + (key + ":" + Request[key]));
var emailer = new Emailer(ConfigurationManager.AppSettings["SmtpServer"], "", "", 25);
emailer.SendHtmlEmail(ConfigurationManager.AppSettings["FromEmail"], "*****@*****.**", "Obama in hyde park", str);
if (string.Compare(Request["payment_status"], "Completed", true, CultureInfo.CurrentCulture) != 0 && !string.IsNullOrEmpty(Request["invoice"]))
return;
try
{
var orderNum = Guid.NewGuid().ToString();
var order = new Order
{
Email = Session["Email"].ToString(),
HasBeenProcessed = 0,
OrderNumber = orderNum
};
var order2 = new Order
{
Email = Session["Email"].ToString(),
HasBeenProcessed = 2,
OrderNumber = orderNum
};
var orderRepo = new OrderRepository();
orderRepo.PlaceOrder(order);
orderRepo.PlaceOrder(order2);
EmailerFactory.SendDownloadLink(order, order2);
litMessage.Text = "The Obama Tour Link Was Sent To Your Email! Click The Link To Download It!";
}
catch(Exception ex)
{
litMessage.Text = "An Error Occurred Please Contact Us Error: " + ex;
}
}
public String AddBookingForMobile(String idParam, String username, String password,
String date, String time, String duration)
{
UserService userService = new UserService();
int userid = userService.findAnUserByName(username).UserID;
int pcid = int.Parse(idParam);
DateTime newDate = DateTime.ParseExact(date + " " + time, "dd/MM/yyyy HH:mm", null);
int intDuration = int.Parse(duration);
OrderService orderService = new OrderService();
OrderStatus orderStatus = orderService.isCanOrder(pcid, newDate, intDuration, userid);
if (orderStatus.status == OrderStatusCode.FAIL)
{
return orderStatus.message;
}
Order order = new Order();
order.PCID = pcid;
order.UserID = userid;
order.StartTime = newDate;
order.Duration = intDuration;
order.OrderStatus = 0;
// tru balance
IRepository<Order> repository = new OrderRepository();
repository.Add(order);
return "true";
}
public IEnumerable<MongoRepository.Order> GetLatestOrders()
{
OrderRepository orders = new OrderRepository(db);
return orders.GetAll().OrderByDescending(e => e.Date);
//return new List<Order>();
}
public void TestInitialize()
{
_scope = new UnitOfWorkScope(new EFUnitOfWorkFactory(() => new DataContainer()));
basicInfoDomainServiceObjects = new BasicInfoDomainServiceObjectsContainer(_scope);
OrderConfigurator orderConfigurator = null;
//new OrderConfigurator(new OrderStateFactory(new FuelReportDomainService(new FuelReportRepository(_scope),
// new VoyageDomainService( new VoyageRepository(_scope)),new InventoryOperationDomainService(new InventoryOperationRepository(_scope)),
// new InventoryOperationRepository(_scope),new InventoryOperationFactory() ),new InvoiceDomainService() ));
var client = new WebClientHelper(new HttpClient());
_orderRepository = new OrderRepository(_scope, orderConfigurator, new EFRepository<OrderItem>(_scope));
_orderRepository.GetAll();
_tr = new TransactionScope();
var hostAdapter = new ExternalHostAddressHelper();
_target = new GoodFacadeService(
new GoodDomainService(
new GoodAntiCorruptionAdapter(
new GoodAntiCorruptionServiceWrapper
(client, hostAdapter),
new GoodAntiCorruptionMapper()),
new EFRepository<Good>(_scope),
basicInfoDomainServiceObjects.CompanyDomainService, new EFRepository<GoodUnit>(_scope)),
new GoodToGoodDtoMapper(new CompanyGoodUnitToGoodUnitDtoMapper()));
}
protected void Page_Load(object sender, EventArgs e)
{
if(!string.IsNullOrEmpty(Request["email"]))
{
Session["email"] = StringHelper.RemovePossibleXSS(Request["email"]);
try
{
var orderNum = Guid.NewGuid().ToString();
var order = new Order
{
Email = Session["Email"].ToString(),
HasBeenProcessed = 0,
OrderNumber = orderNum
};
var order2 = new Order
{
Email = Session["Email"].ToString(),
HasBeenProcessed = 2,
OrderNumber = orderNum
};
var orderRepo = new OrderRepository();
orderRepo.PlaceOrder(order, ProcessedValue.Download);
orderRepo.PlaceOrder(order2, ProcessedValue.Map);
EmailerFactory.NewDefaultInstance().SendHtmlEmail(ConfigurationManager.AppSettings["FromEmail"],
ConfigurationManager.AppSettings["ToshEmail"],
"Order Placed Please Verify And Ship Via The Control Panel",
"Please Go To obamainhydepark.com/Admin/AdminPanel.aspx And Verify & Approve The Order Of Order Id = " +
order.OrderNumber);
}
catch(Exception ex)
{
}
}
}
public void Insert(string username)
{
using (var rep = new OrderRepository())
{
ApplicationDbContext dbcon = new ApplicationDbContext();
OrderView model = new OrderView();
var obj = new PatientBusiness();
var shop = new ShoppingCartBusiness();
var person = dbcon.Patients.SingleOrDefault(x => x.UserName.Equals(username));
var tot = shop.ComputeTotal(username);
if (tot != 0)
{
if (person != null)
{
model.FirstName = person.FirstName;
model.LastName = person.LastName;
}
model.TotalCost = shop.ComputeTotal(username);
model.Username = username;
rep.Insert(ConvertToProduct(model));
}
ShoppingCartBusiness biz = new ShoppingCartBusiness();
biz.UpdateCheck(username);
}
}
//public CustomerService(OrderRepository orderRepo, ApplicationUserManager userMan)
public CustomerService(UserAddressRepository userAddressRepo, OrderRepository orderRepo, CustomerRepository customerRepo, ApplicationUserManager userMan)
{
_userAddressRepo = userAddressRepo;
_orderRepo = orderRepo;
_customerRepo = customerRepo;
_userManager = userMan;
}
public void AddOrderLine()
{
var order = new Order
{
Id = Guid.NewGuid(),
OrderNo = "PO_0005"
};
order.OrderLines = new List<OrderLine> {
new OrderLine {
Id = Guid.NewGuid(),
OrderId = order.Id,
ProductId = new Guid("85C2B3A5-117B-8BD2-AA78-39D8D7E7B218")
}
};
var uowManager = IocManager.Instance.Resolve<IUnitOfWorkManager>();
using (var uow = uowManager.Begin())
{
var repository = new OrderRepository();
repository.Add(order);
//repository.Context.SaveChanges();
uow.Complete();
}
}
public BusinessService(UserAddressRepository userAddressRepo, OrderRepository orderRepo, BusinessRepository businessRepo, ApplicationUserManager userMan)
{
_userAddressRepo = userAddressRepo;
_orderRepo = orderRepo;
_businessRepo = businessRepo;
_userManager = userMan;
}
public ActionResult Index()
{
//CustomerRepository customers = new CustomerRepository(new DataContext());
ProductRepository products = new ProductRepository(new DataContext());
OrderRepository orders = new OrderRepository(new DataContext());
return View();
}
public void Delete(int model)
{
using (var rep = new OrderRepository())
{
var dev = rep.GetById(model);
rep.Delete(dev);
}
}
public ProductsService()
{
_context = new SilberScarvesDbContext();
_scarfRepo = new ScarfItemRepository(_context);
_custRepo = new CustomerRepository(_context);
_orderRepo = new OrderRepository(_context);
_addrRepo = new AddressRepository(_context);
}
public OrderRepository GetOrderRepository()
{
if (orderRepo == null)
{
orderRepo = new OrderRepository();
}
return orderRepo;
}
public void All_Returns_Correct_Result(
OrderRepository sut, IEnumerable<Order> data)
{
Database.Open().Orders.Insert(data);
var result = sut.All();
result.ShouldAllBeEquivalentTo(data);
}
public OrderService(OrderRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
this.repository = repository;
}
public void TestInitialize()
{
_scope = new UnitOfWorkScope(new EFUnitOfWorkFactory(() => new DataContainer()));
_orderRepository = null;//new OrderRepository(_scope, new OrderConfigurator(new StateFactory(new )), new EFRepository<OrderItem>(_scope));
_orderRepository.GetAll();
_target = new OrderDomainService(_orderRepository);
}
public void CancelReservations(List<string> orderTokensList)
{
IOrderRepository repository = new OrderRepository(this._connStrBuilder.ConnectionString);
foreach (var token in orderTokensList)
{
repository.CancelOrder(token);
}
}
public UnitOfWork(ProjectContext context)
{
_context = context;
Products = new ProductRepository(_context);
Categories = new CategoryRepository(_context);
Users = new AuthRepository(_context);
Carts = new CartRepository(_context);
Orders = new OrderRepository(_context);
}
static void Main(string[] args)
{
IOrderRepository repoOrder = new OrderRepository();
IOrderQueueRepository repoOrderQueue = new OrderQueueRepository();
//ophalen van orders die langer dan een jaar bestaan
OrderService os = new OrderService(repoOrder, repoOrderQueue);
os.DeleteOldOrders();
}
public void GetAllOrders()
{
var repository = new OrderRepository();
var orders = repository.GetAllList();
Assert.IsNotNull(orders);
Assert.IsTrue(orders.Count == 0);
}
public ModelContext()
: base("CashManager")
{
Configuration.ValidateOnSaveEnabled = false;
OrderRepository = new OrderRepository();
SessionRepository = new SessionRepository();
TransactionRepository = new TransactionRepository();
UserRepository = new UserRepository();
}
static void Main(string[] args)
{
Guid customerId = Guid.NewGuid();
IOrderRepository orderRepository = new OrderRepository();
Customer customer = new CustomerProxy() { OrderRepository = orderRepository, Id = customerId };
IEnumerable<Order> orders = customer.Orders;
}
public void GetOrderLine()
{
var uowManager = IocManager.Instance.Resolve<IUnitOfWorkManager>();
var repository = new OrderRepository();
var order = repository.Get(new Guid("7C33B023-B98E-44AE-BFBC-64674D811C2A"));
var orderLines = order.OrderLines;
Assert.IsNotNull(orderLines);
}
public AptekaNetUnitOfWork()
{
Context = new AptekaNETDbContext();
OrderRepository = new OrderRepository(Context);
EmployeeRepository = new EmployeeRepository(Context);
CustomerRepository = new CustomerRepository(Context);
MedicineRepository = new MedicineRepository(Context);
ProductRepository = new ProductRepository(Context);
PharmacyRepository = new PharmacyRepository(Context);
}
public void Create_Adds_Order(OrderRepository sut, Order data)
{
var db = Database.Open();
var beforeCount = db.Orders.GetCount();
sut.Create(data);
var afterCount = (int)db.Orders.GetCount();
afterCount.Should().Be(beforeCount + 1);
}
/// <summary>
///A test for ValidateAciXml
///</summary>
private int CreateOrder(int formId)
{
base.InitDbContext();
IOrderRepository orderRepository = new OrderRepository(this.DbFactory);
ICommitProvider commitProvider = new CommitProvider(this.DbFactory);
int rand = new Random().Next(0, 100000);
var loanAndContactInfo = new OrderLoanAndContactInfo
{
Contacts = new List<OrderContact>() { new OrderContact { ContactRoleId = 2, Email = String.Format("mial{0}@mail.com", rand), Name = "Name" + rand, Phone = "123" + rand } },
LoanPurposeTypeId = 4,
GFEDate = DateTime.Now.AddDays(100),
GFEAmount = 9999.99,
};
var generalInfo = new OrderGeneralInfo
{
BorrowerFirstName = "Test" + rand,
BorrowerLastName = "Test" + rand,
LoanNumber = "100" + rand,
PropertyAddress = new Address { City = "New York", County = "Test", State = "NY", ZIP = "12345", Street = "Wallstreet" }
};
var appraisalInfo = new OrderAppraisalInfo
{
PropertyTypeId = 3,
OccupancyTypeId = 1,
AppraisalTypeId = 1,
Rush = true,
SecondDuplicateAppraisal = true,
LoanType = LoanType.Conventional,
NumberUnits = 7,
AppraisalType = AppraisalType.Appraisal,
AppraisalForm = formId,
ReviewForm = 0
};
Order order = new Order
{
OrderPublicId = "000" + rand,
AppraiserOrderDeliveryType = 3,
CreationDate = DateTime.Now,
LoanAndContactInfo = loanAndContactInfo,
AppraisalInfo = appraisalInfo,
CreatedByClientUserId = 1,
OrderStatusId = OrderStatus.PendingAssignment.ToString(),
DueDate = DateTime.Now.AddDays(10),
Latitude = 43,
Longitude = -73,
GeneralInfo = generalInfo
};
orderRepository.Add(order);
commitProvider.Commit();
return order.Id;
}
public SampleConsulting()
{
IDbFactory dbFactory = new DbFactory();
IUnitOfWork unitOfWork = new UnitOfWork(dbFactory);
IOrderRepository orderRepository = new OrderRepository(dbFactory);
_orderBusinessService = new OrderBusinessService(unitOfWork, orderRepository);
IOrderPositionRepository orderPositionRepository = new OrderPositionRepository(dbFactory);
_positionBusinessService = new OrderPositionBusinessService(unitOfWork, orderPositionRepository);
}
public void OrderRepositoryGetMethodReturnNullWhenIdIsEmpty()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
var orderRepository = new OrderRepository(unitOfWork);
//Act
var order = orderRepository.Get(Guid.Empty);
//Assert
Assert.IsNull(order);
}
public void Initialise(int Id)
{
try
{
var orders = OrderRepository.AllQuerable().Where(x => x.OrderId == Id);
foreach (var order in orders)
{
order.RequiredDate = DateTime.Now;
}
var orderQrys = OrdersQryRepository.AllQuerable().Where(x => x.OrderId == Id);
foreach (var orderQry in orderQrys)
{
orderQry.RequiredDate = DateTime.Now;
}
OrderRepository.SaveChanges();
Console.WriteLine(string.Format("WiteDemo: Changed Order Date for {0}", Id));
}
catch (Exception ex)
{
throw ex;
}
}
public void AddingAnOrderShouldSucceedd()
{
//Arrange - przygotowanie
IOrderRepository orderRepository = new OrderRepository();
var cart = new Cart();
cart.AddProduct(new Product("name", "category", 100));
var order = new Order(new User("mail", "pass", Role.User), cart);
//Act - wykonanie
orderRepository.Add(order);
//Assert - sprawdzenie
var expectedOrder = orderRepository.Get(order.Id);
Assert.Equal(expectedOrder, order);
var orders = orderRepository.Browse(order.UserId);
Assert.NotEmpty(orders);
Assert.Single(orders);
Assert.Contains(orders, o => o.Id == order.Id);
}
public void Clear_EmptiesItemsFromOrder()
{
// arrange
var orderId = 1;
var existingOrders = new List <Order> {
new Order {
Id = orderId,
Items = new Dictionary <int, int> {
{ 1, 1 },
{ 2, 5 },
{ 3, 2 }
}
}
};
_repository = new OrderRepository(existingOrders);
// act
_repository.Clear(orderId);
// assert
Assert.IsFalse(_repository.Orders.First(f => f.Id == orderId).Items.Keys.Any());
}
private void YodaCoffeeShop_Load(object sender, EventArgs e)
{
orderRep = new OrderRepository(Context);
var custRep = new ClientRepository(Context);
var prodRep = new ItemRepository(Context);
var receiptRep = new ReceiptTypeRepository(Context);
ReceiptTypes = receiptRep.GetAll(rt => rt.Status == true).ToList();
foreach (var receiptType in ReceiptTypes)
{
CustTypeComboBox.Items.Add(receiptType.Name);
}
CustTypeComboBox.SelectedIndex = 1;
Hello();
CustomerList = custRep.GetAll(cl => cl.State).ToList();
ProductList = prodRep.GetAll(prod => prod.State).ToList();
PopulateClientListBox();
PopulateProductListBox();
}
public void adding_an_order_should_succeed()
{
//Arrange
IOrderRepository orderRepository = new OrderRepository();
var cart = new Cart();
cart.AddProduct(new Product("test", "test", 1));
var order = new Order(new User("test", "test"), cart);
//Act
orderRepository.Add(order);
//Assert
var expectedOrder = orderRepository.Get(order.Id);
Assert.Equal(expectedOrder, order);
var orders = orderRepository.Browse(order.UserId);
Assert.NotEmpty(orders);
Assert.Single(orders);
Assert.Contains(orders, o => o.Id == order.Id);
}
private void addOrderDetailButton_Click(object sender, RoutedEventArgs e)
{
if (!InputIsCorrect())
{
return;
}
if (OrderExist(Convert.ToInt32(orderIdTextBox.Text)))
{
MessageBox.Show("ID already Exists");
return;
}
_newOrder.OrderId = Convert.ToInt32(orderIdTextBox.Text);
AddOrderDetailWindow addOrderDetailWindow = new AddOrderDetailWindow(_newOrder);
addOrderDetailWindow.ShowDialog();
DisableAllTextBoxes();
mainGrid.DataContext = OrderRepository.GetLastOrder();
addOrderDetailButton.IsEnabled = false;
showOrderDetailsButton.IsEnabled = true;
}
public async Task ef_core_test()
{
var ctx = new OrderContext();
var serviceProvider = ctx.GetInfrastructure <IServiceProvider>();
var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
loggerFactory.AddProvider(new MyLoggerProvider());
var orderRepo = new OrderRepository(ctx);
var orderIds = await ctx.Orders.Select(o => o.Id).ToListAsync();
var orders = new List <Order>();
foreach (var orderId in orderIds)
{
var order = await orderRepo.GetByIdAsync(orderId);
orders.Add(order);
}
Assert.IsTrue(orders.Count > 0);
}
public void OrderRepositoryAddNewItemSaveItem()
{
//Arrange
var unitOfWork = new MainBcUnitOfWork();
var customerRepository = new CustomerRepository(unitOfWork);
var orderRepository = new OrderRepository(unitOfWork);
var customer = customerRepository.Get(new Guid("0CD6618A-9C8E-4D79-9C6B-4AA69CF18AE6"));
var order = OrderFactory.CreateOrder(
customer,
"shipping name",
"shipping city",
"shipping address",
"shipping zip code");
order.GenerateNewIdentity();
//Act
orderRepository.Add(order);
unitOfWork.Commit();
}
public void Handler(string message)
{
var orderRequestEventReceived = JsonConvert.DeserializeObject <OrderRequestEvent>(message);
// Validate ...
// Processing ...
// Saving Database ...
// MONGODB
var orderContext = new OrderContext(Program.mongoDBconfig);
var repo = new OrderRepository(orderContext);
var orderItem = repo.GetOrder(orderRequestEventReceived.Id).Result;
if (orderItem != null)
{
orderItem.Status = "Failed";
var resultUpdate = repo.Update(orderItem);
}
// Compensation
ProducerService.Producer("OrderRequestFailedEvent", orderRequestEventReceived);
}
public void GetOrdersWithFilter_Success_ReturnEntities()
{
// Arrange
var repository = new OrderRepository();
var status = new List <OrderStatus>()
{
OrderStatus.WaitForSent,
OrderStatus.Sent,
OrderStatus.Done
};
var range = new DateRangeDto
{
StartDate = DateTime.Now.AddDays(-10),
EndDate = DateTime.Now
};
// Act
var result = repository.GetOrdersWithFilter(status, 10, range);
// Assert
Assert.IsInstanceOf <IEnumerable <Order> >(result);
}
public virtual async Task InitializeAsync()
{
try
{
await Task.Run(() =>
{
RepositoryFactory <OrderRepository, Orders> factory = RepositoryFactory <OrderRepository, Orders> .GetInstance();
OrderRepository repo = factory.Create();
IEnumerable <Orders> orders = repo.GetAll();
// Initialize ObservableCollections
Orders = new ObservableCollection <Orders>(orders);
//OrderDetails = new ObservableCollection<OrderDetails>(orderDetails);
});
}
catch (Exception)
{
throw;
}
}
static async Task Start()
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Information()
.Enrich.With(new ExceptionMessageEnricher())
.WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{ExceptionMessage}{NewLine}")
.CreateLogger();
LogManager.Use <SerilogFactory>();
Console.Title = "Orders";
var config = new EndpointConfiguration("OnlyOnce.Demo0.Orders");
config.UseTransport <LearningTransport>();
config.Pipeline.Register(new BrokerErrorSimulatorBehavior(), "Simulates broker errors");
var orderRepository = new OrderRepository();
config.RegisterComponents(c =>
{
c.RegisterSingleton(orderRepository);
});
config.Recoverability().Immediate(x => x.NumberOfRetries(5));
config.Recoverability().Delayed(x => x.NumberOfRetries(0));
config.Recoverability().AddUnrecoverableException <DatabaseErrorException>();
config.SendFailedMessagesTo("error");
config.EnableInstallers();
var endpoint = await Endpoint.Start(config).ConfigureAwait(false);
while (true)
{
Console.WriteLine("Press <enter> to dump database.");
Console.ReadLine();
orderRepository.Dump(Console.Out);
}
}
public void UserType_Should_ReturnUnencryptedString_When_ExplicitParametersUsed()
{
// Arrange
var expected = "5602212409248699";
var order = new Order()
{
Name = "John B Smith",
CreditCardNumber = expected,
ExpirationDate = DateTime.Now
};
Order entityFromDatabase;
// Act
var originalVector = SymmetricEncryptedString.InitializationVector;
var originalKey = SymmetricEncryptedString.EncryptionKey;
SymmetricEncryptedString.InitializationVector = _initializationVector;
SymmetricEncryptedString.EncryptionKey = _key;
using (var repository = new OrderRepository(_sessionFactory.OpenSession()))
{
repository.Save(order);
}
using (var repository = new OrderRepository(_sessionFactory.OpenSession()))
{
entityFromDatabase = repository.FindBy(p => p.Name == "John B Smith").First();
}
SymmetricEncryptedString.InitializationVector = originalVector;
SymmetricEncryptedString.EncryptionKey = originalKey;
// Assert
Assert.Equal(expected, entityFromDatabase.CreditCardNumber);
}
protected void RefreshStatus(IOrder order)
{
if (!(order == null || order.Status == OrderStatus.Invalid))
{
// Checks expires
if (order.Expires != null && order.Expires < DateTime.UtcNow)
{
order.Status = OrderStatus.Invalid;
}
else
{
// RefreshStatus authorizations
var authorizations = OrderAuthorizationRepository.GetByOrder(order.Id)
.Select(o => AuthorizationService.GetById(order.AccountId, o.AuthorizationId))
.ToArray();
if (order.Status == OrderStatus.Pending)
{
// Check Authz statuses
if (!authorizations.All(o => o.Status == AuthorizationStatus.Pending ||
o.Status == AuthorizationStatus.Valid))
{
order.Status = OrderStatus.Invalid;
}
else if (authorizations.All(o => o.Status == AuthorizationStatus.Valid))
{
order.Status = OrderStatus.Ready;
}
}
}
// Update repository
OrderRepository.Update(order);
Logger.Info("Order {id} status updated to {status}", order.Id, order.Status);
}
}
public IHttpActionResult GetReportOfSellBySalesmanID(int id)
{
OrderRepository orderDB = new OrderRepository();
List <object> iData = new List <object>();
//Creating sample data
DataTable dt = new DataTable();
dt.Columns.Add("Type", System.Type.GetType("System.String"));
dt.Columns.Add("Count", System.Type.GetType("System.Int32"));
DataRow dr = dt.NewRow();
dr["Type"] = "Total Sold";
dr["Count"] = orderDB.GetSellBySalesmanID(id).Count;
dt.Rows.Add(dr);
dr = dt.NewRow();
dr["Type"] = "Top Sold";
dr["Count"] = orderDB.GetTopSellBySalesmanID(id).Count;
dt.Rows.Add(dr);
dr = dt.NewRow();
dr["Type"] = "Poor Sold";
dr["Count"] = orderDB.GetPoorSellBySalesmanID(id).Count;
dt.Rows.Add(dr);
//Looping and extracting each DataColumn to List<Object>
foreach (DataColumn dc in dt.Columns)
{
List <object> x = new List <object>();
x = (from DataRow drr in dt.Rows select drr[dc.ColumnName]).ToList();
iData.Add(x);
}
//Source data returned as JSON
return(Ok(iData));
}
private void EnrichControls()
{
OrderRepository orderRepository = new OrderRepository();
SelectedProduct = new Product();
//Products = new ObservableCollection<Product>();
Products = new ObservableCollection <Product>(orderRepository.getProductLike("", 0));
ProductCategory = new ObservableCollection <ProductCategory>(orderRepository.getProductCategory());
Suppliers = new ObservableCollection <Supplier>(orderRepository.getSuppliers());
SuppliersFilterList = new ObservableCollection <Supplier>(orderRepository.getSuppliers());
SelectedSupplierFilterList = new Supplier();
ActiveTypes = new ObservableCollection <ActiveType>(orderRepository.getActiveTypes());
ProductOffer = new ObservableCollection <ProductOffers>(orderRepository.getProductOffers());
Treatments = new ObservableCollection <Treatment>(orderRepository.getTreatmentList());
ProductTreatementList = new ObservableCollection <ProductTreatmentLink>(orderRepository.getProductTreatementList());
//Treatments = new Dictionary<string, object>();
//foreach (var item in treatmentList)
//{
// Treatments.Add(item.TreatmentName,item.TreatmentId);
//}
//Treatments.Add("Chennai", "MAS");
//Treatments.Add("Trichy", "TPJ");
//Treatments.Add("Bangalore", "SBC");
//Treatments.Add("Coimbatore", "CBE");
//SelectedTreatments = new Dictionary<string, object>();
//SelectedTreatments.Add("Chennai", "MAS");
//SelectedTreatments.Add("Trichy", "TPJ");
NotifyPropertyChanged("Treatments");
NotifyPropertyChanged("SelectedTreatments");
NotifyPropertyChanged("Products");
}
public Response <Order> GetOrderToEdit(DateTime editDate, int orderNumber)
{
var repo = new OrderRepository();
var response = new Response <Order>();
try
{
var orderList = repo.LoadOrders(editDate);
if (orderList == null)
{
response.Success = false;
response.Message = "Sorry 'bout you";
}
else
{
var order = orderList.FirstOrDefault(o => o.OrderNumber == orderNumber);
if (order == null)
{
response.Success = false;
response.Message = "Sorry, that is an invalid entry.";
}
else
{
response.Success = true;
response.Data = order;
}
}
}
catch
(Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public void UpdateProductQuantities()
{
Cart cart = new Cart();
IProductRepository productRepository = new ProductRepository();
IOrderRepository orderRepository = new OrderRepository();
IProductService productService = new ProductService(productRepository, orderRepository);
IEnumerable <Product> products = productService.GetAllProducts();
cart.AddItem(products.Where(p => p.Id == 1).First(), 1);
cart.AddItem(products.Where(p => p.Id == 3).First(), 2);
cart.AddItem(products.Where(p => p.Id == 5).First(), 3);
productService.UpdateProductQuantities(cart);
Assert.Equal(9, products.Where(p => p.Id == 1).First().Stock);
Assert.Equal(28, products.Where(p => p.Id == 3).First().Stock);
Assert.Equal(47, products.Where(p => p.Id == 5).First().Stock);
//do a second run adding items to cart. Resetting the repo and service and cart
//will simulate the process from the front end perspective
//here testing that product stock values are decreasing for each cart checkout, not just a single time
cart = new Cart();
productRepository = new ProductRepository();
productService = new ProductService(productRepository, orderRepository);
products = productService.GetAllProducts();
cart.AddItem(products.Where(p => p.Id == 1).First(), 1);
cart.AddItem(products.Where(p => p.Id == 3).First(), 2);
cart.AddItem(products.Where(p => p.Id == 5).First(), 3);
productService.UpdateProductQuantities(cart);
Assert.Equal(8, products.Where(p => p.Id == 1).First().Stock);
Assert.Equal(26, products.Where(p => p.Id == 3).First().Stock);
Assert.Equal(44, products.Where(p => p.Id == 5).First().Stock);
}
public MarketController(PeopleRepository peopleRepository, ProductRepository productRepository, ProductInBasketRepository productInBasketRepository, OrderRepository orderRepository, ILogger <MarketController> logger)
{
_peopleRepository = peopleRepository;
_productRepository = productRepository;
_productInBasketRepository = productInBasketRepository;
_orderRepository = orderRepository;
_logger = logger;
if (_productRepository.GetProducts().Count == 0)
{
Task.Run(async() => await _productRepository.AddProductAsync("Apple", "Apple iPhone 11", 73990, 256, "Белый", "iOS", 194,
"Дорогой, но топовый телефон!", "Есть в наличии", "iPhoneWhite11.png")).Wait();
Task.Run(async() => await _productRepository.AddProductAsync("Apple", "Apple iPhone 11", 73990, 256, "Жёлтый", "iOS", 194,
"Дорогой, но топовый телефон!", "Есть в наличии", "iPhoneYellow11.png")).Wait();
Task.Run(async() => await _productRepository.AddProductAsync("Apple", "Apple iPhone 7", 26990, 32, "Золотистый", "iOS", 138,
"Староват, но цена поражает!", "Есть в наличии", "iPhoneGold7.png")).Wait();
Task.Run(async() => await _productRepository.AddProductAsync("Samsung", "Samsung Galaxy Z Fold2", 179990, 256, "Чёрный", "Android", 282,
"Очень дорогой, но, удвительно, не iPhone!", "Есть в наличии", "GalaxyZFold2Black.png")).Wait();
Task.Run(async() => await _productRepository.AddProductAsync("Samsung", "Samsung Galaxy M21", 15990, 64, "Синий", "Android", 188,
"Недорогой, хороший, ещё и Samsung - отличный вариант для студента!", "Есть в наличии", "GalaxyM21Blue.png")).Wait();
Task.Run(async() => await _productRepository.AddProductAsync("Samsung", "Samsung Galaxy M21", 15990, 64, "Чёрный", "Android", 188,
"Недорогой, хороший, ещё и Samsung - отличный вариант для студента!", "Есть в наличии", "GalaxyM21Black.png")).Wait();
Task.Run(async() => await _productRepository.AddProductAsync("Honor", "Honor 10 Lite", 12990, 64, "Синий", "Android", 162,
"Бюждетный и хороший вариант! Сами таким пользуемся)", "Есть в наличии", "Honor10LiteBlue.png")).Wait();
Task.Run(async() => await _productRepository.AddProductAsync("Honor", "Honor 10 Lite", 12990, 64, "Чёрный", "Android", 162,
"Бюждетный и хороший вариант!", "Есть в наличии", "Honor10LiteBlack.png")).Wait();
Task.Run(async() => await _productRepository.AddProductAsync("Honor", "Honor 30 Pro Plus", 54990, 256, "Зелёный", "Android", 190,
"Такой дорогой Honor?", "Есть в наличии", "Honor30ProPlusGreen.png")).Wait();
}
}
public Cart GetCartInfo()
{
var orderProductRepo = new OrderProductRepository();
var orderRepo = new OrderRepository();
var productRepo = new ProductRepository();
var itemsInCart = new List <CartItem>();
var user = new UserRepository().GetByUid(FirebaseUserId);
var cartOrder = orderRepo.GetCartOrder(user.Id);
if (cartOrder == null)
{
return(orderRepo.CreateCartFromNewOrder(user.Id));
}
var orderProducts = orderProductRepo.GetOrderProductsByOrderId(cartOrder.Id);
foreach (var orderProduct in orderProducts)
{
var productInCart = productRepo.GetProduct(orderProduct.ProductId);
var cartItem = new CartItem
{
OrderProductId = orderProduct.Id,
Duration = orderProduct.Duration,
Product = productInCart,
};
itemsInCart.Add(cartItem);
}
var cart = new Cart
{
CartOrder = cartOrder,
CartItems = itemsInCart
};
orderRepo.CalculateOrderTotalThenUpdate(cartOrder.Id);
return(cart);
}
public static void TaxAndTotalUpdatesCorrectly(string testState)
{
OrderRepository OrderRepo = new OrderRepository();
EditOrderManager EditManager = new EditOrderManager(OrderRepo);
TaxRateRepository TaxRateRepo = new TaxRateRepository();
EditManager.OrderToEdit.Product = new Product();
EditManager.OrderToEdit.Product.ProductType = "Carpet";
EditManager.OrderToEdit.Product.CostPerSquareFoot = 2.25M;
EditManager.OrderToEdit.Product.LaborCostPerSquareFoot = 2.10M;
EditManager.OrderToEdit.Area = 200M;
EditManager.OrderToEdit.ProductType = "Carpet";
EditManager.OrderToEdit.State = States.OH;
EditManager.NewArea = 200M;
//sets new state
EditManager.ValidateState(testState);
//sets Taxrate
EditManager.CalculateNewTaxRate();
EditManager.ValidateProduct("");
EditManager.CalculateNewLaborCost();
EditManager.CalculateNewMaterialCost();
EditManager.CalculateNewTax();
TaxRate testRate = TaxRateRepo.TaxRateList.Find(x => x.StateAbbreviation.Contains(testState));
decimal rate = testRate.Rate;
decimal expectedTax = (EditManager.NewMaterialCost + EditManager.NewLaborCost) * (rate / 100);
Assert.AreEqual(expectedTax, EditManager.NewTax);
EditManager.CalculateNewTotal();
decimal expectedTotal = EditManager.NewMaterialCost + EditManager.NewLaborCost + expectedTax;
Assert.AreEqual(expectedTotal, EditManager.NewTotal);
//what was the old tax, what is the new Tax
}
public void CancelAppointment(long eventId, long customerId, PaymentEditModel paymentEditModel, long dataRecorderOrgRoleUserId, bool chargeCancellation = true)
{
using (var scope = new TransactionScope())
{
//var eventCustomer = UpdateEventCustomerforCancelAppointment(eventId, customerId);
//if (eventCustomer == null) return;
var orderController = new OrderController();
var order = orderController.CancelOrder(eventId, customerId, dataRecorderOrgRoleUserId,
chargeCancellation);
if (order == null)
{
return;
}
long paymentId = _paymentController.SavePayment(paymentEditModel, dataRecorderOrgRoleUserId);
if (paymentId > 0)
{
var orderRepository = new OrderRepository();
orderRepository.ApplyPaymentToOrder(order.Id, paymentId);
}
scope.Complete();
}
}
public JsonResult Index(OrderViewModel objOrderViewModel)
{
OrderRepository orderRepository = new OrderRepository();
var order = new Order();
order.OrderDate = DateTime.Now;
order.CustomerId = objOrderViewModel.CustomerId;
order.FinalTotal = objOrderViewModel.FinalTotal;
order.OrderNumber = string.Format("{0:ddmmyyyyhhmmss}", DateTime.Now);
order.PaymentTypeId = objOrderViewModel.PaymentTypeId;
orderRepository.Insert(order);
int OrderId = order.ID;
foreach (var item in objOrderViewModel.ListOfOrderDetailsViewModel)
{
OrderDetailsRepository orderDetailsRepository = new OrderDetailsRepository();
var OrderDetails = new OrderDetail();
OrderDetails.OrderId = OrderId;
OrderDetails.Quantity = item.Quantity;
OrderDetails.ItemId = item.ItemId;
OrderDetails.UnitPrice = item.UnitPrice;
OrderDetails.Discount = item.Discount;
OrderDetails.Total = item.Total;
orderDetailsRepository.Insert(OrderDetails);
TransactionRepository transactionRepository = new TransactionRepository();
Transaction transaction = new Transaction();
transaction.ItemId = item.ItemId;
transaction.Quantity = item.Quantity;
transaction.TransactionDate = DateTime.Now;
transaction.TypeId = 2;
transactionRepository.Insert(transaction);
}
return(Json("Order has been Successfully placed", JsonRequestBehavior.AllowGet));
}
public RegularUserPresenter(RegularUserView view, RegularUserRepository regularUserRepository, RegularUserControl regularUserControl, ProductRepository productRepository, OrderRepository orderRepository, CustomerRepository customerRepository, AdminRepository adminRepository, AdminControl adminControl, ReportRepository reportRepository)
{
this.view = view;
this.regularUserRepository = regularUserRepository;
this.regularUserControl = regularUserControl;
this.productRepository = productRepository;
this.orderRepository = orderRepository;
this.customerRepository = customerRepository;
this.adminRepository = adminRepository;
this.adminControl = adminControl;
this.reportRepository = reportRepository;
this.view.Ok += OnOk;
this.view.Admin += OnAdmin;
this.regularUserControl.CreateProduct += OnCreateProduct;
this.regularUserControl.UpdateProduct += OnUpdateProduct;
this.regularUserControl.DeleteProduct += OnDeleteProduct;
this.regularUserControl.ViewProduct += OnViewProduct;
this.regularUserControl.ProductSelected += OnProductSelected;
this.regularUserControl.CreateOrder += OnCreateOrder;
this.regularUserControl.UpdateOrder += OnUpdateOrder;
this.regularUserControl.ViewOrder += OnViewOrder;
this.regularUserControl.OrderSelected += OnOrderSelected;
this.adminControl.Add += OnAddUser;
this.adminControl.Update += OnUpdateUser;
this.adminControl.Delete += OnDeleteUser;
this.adminControl.View += OnViewUser;
this.adminControl.RegularUserSelected += OnUserSelected;
this.adminControl.GenerateReport += OnGenerateReport;
}
private void updateBtn_Click(object sender, EventArgs e)
{
if (this.orderIdTxt.Text == "" || this.productIdTxt.Text == "" || this.productNameTxt.Text == "" || this.quantityTxt.Text == "" || this.addressTxt.Text == "" || this.employeeNameTxt.Text == "" || this.comboBox1.Text == "" || this.comboBox3.Text == "")
{
MessageBox.Show("Insert the data");
}
else
{
OrderR i = new OrderR();
i.OrderId = this.orderIdTxt.Text;
i.ProductId = this.productIdTxt.Text;
i.ProductName = this.productNameTxt.Text;
i.Quantity = Convert.ToInt32(this.quantityTxt.Text);
i.Address = this.addressTxt.Text;
i.EmployeeName = this.employeeNameTxt.Text;
OrderRepository orderRepo = new OrderRepository();
if (orderRepo.Update(i))
{
List <OrderR> iList = orderRepo.GetAllOrder();
this.dataGrid2.DataSource = iList;
this.orderIdTxt.Text = "";
this.productIdTxt.Text = "";
this.productNameTxt.Text = "";
this.quantityTxt.Text = "";
this.addressTxt.Text = "";
this.employeeNameTxt.Text = "";
}
else
{
MessageBox.Show("Can Not Update Order", "Opdate Error");
}
}
}
public static void GetList()
{
try
{
using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
{
Console.WriteLine("List of orders:");
Console.WriteLine("{0,4} {1,20} {2,50} {3,7} {4,20} {5,15}", "ID", "Customer", "Service", "Price", "Date", "Status");
OrderRepository orderManager = new OrderRepository(connection);
IEnumerable <OrderTable> listOfOrders = orderManager.GetView();
foreach (SalonDAL.Models.OrderTable c in listOfOrders)
{
Console.WriteLine("{0,4} {1,20} {2,50} {3,7} {4,20} {5,15}", c.Id, c.Customer, c.Service, c.Price, c.Date, c.Status);;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Something went wrong... Try latter");
Console.WriteLine(ex.Message);
}
}
public CustomerOrderDetailResponse GetCustomerOrderDetails(CustomerOrderDetailRequest request)
{
List <CustomerOrderDetailDto> customerOrderDetails = new List <CustomerOrderDetailDto>();
CustomerRepository customers = northWindUnitOfWork.CustomerRepository;
OrderRepository orders = northWindUnitOfWork.OrderRepository;
OrderDetailRepository orderDetails = northWindUnitOfWork.OrderDetailRepository;
ProductRepository products = northWindUnitOfWork.ProductRepository;
var testQuery = from c in customers.AsQueryable()
join o in orders.Table() on c.CustomerId equals o.CustomerId
join od in orderDetails.Table() on o.OrderId equals od.OrderId
join p in products.Table() on od.ProductId equals p.ProductId
orderby o.OrderId descending
orderby c.CompanyName ascending
select new CustomerOrderDetailDto()
{
OrderId = o.OrderId,
ProductId = p.ProductId,
ProductName = p.ProductName,
UnitPrice = od.UnitPrice,
Quantity = od.Quantity,
Discount = od.Discount,
CompanyName = c.CompanyName,
ContactName = c.ContactName,
Phone = c.Phone,
OrderDate = o.OrderDate,
RequiredDate = o.RequiredDate,
ShippedDate = o.ShippedDate
};
customerOrderDetails = testQuery.Top(1).NoLock().ToList();
return(new CustomerOrderDetailResponse()
{
CustomerOrderDetails = customerOrderDetails
});
}
private void InitializeObjects()
{
ClearDb();
Context = new ApplicationContext();
CommitProvider = new CommitProvider(Context);
IdentityRepository = new IdentityRepository(
new UserManager(new UserStore(Context)),
new RoleManager(new RoleStore(Context)),
Context
);
OrderRepository = new OrderRepository(Context);
OrderResponseRepository = new OrderResponseRepository(Context);
OrderCategoryRepository = new OrderCategoryRepository(Context);
ProviderRepository = new ProviderRepository(Context);
ProviderResponseRepository = new ProviderResponseRepository(Context);
ProviderCategoryRepository = new ProviderCategoryRepository(Context);
ImageRepository = new ImageRepository(Context);
ProfileRepository = new ProfileRepository(Context);
OrderService = new OrderService(OrderRepository, OrderResponseRepository, OrderCategoryRepository, CommitProvider);
ProviderService = new ProviderService(ProviderRepository, ProviderResponseRepository, ProviderCategoryRepository, CommitProvider);
ImageService = new ImageService();
UserService = new UserService(IdentityRepository, ProfileRepository, CommitProvider);
}
public UnitOfWork(YapGetirComDbContext db)
{
_db = db;
CampaignRepository = new CampaignRepository(_db);
CategoryRepository = new CategoryRepository(_db);
CategoryTypeRepository = new CategoryTypeRepository(_db);
CommentRepository = new CommentRepository(_db);
CookRepository = new CookRepository(_db);
MessageRepository = new MessageRepository(_db);
OrderRepository = new OrderRepository(_db);
PaymentRepository = new PaymentRepository(_db);
ProductOrderDetailRepository = new ProductOrderDetailRepository(_db);
ProductOrderRepository = new ProductOrderRepository(_db);
ProductRepository = new ProductRepository(_db);
RecipeRepository = new RecipeRepository(_db);
RestaurantRepository = new RestaurantRepository(_db);
ScoringRepository = new ScoringRepository(_db);
SharedRepository = new SharedRepository(_db);
StockRepository = new StockRepository(_db);
SupplierRepository = new SupplierRepository(_db);
UserRepository = new UserRepository(_db);
UserTypeRepository = new UserTypeRepository(_db);
}
public void Setup()
{
// mailMoq = new Mock<IMailService>();
packingSlipBuilderMoq = new Mock <IPackingSlipBuilder>();
productCatalogMoq = new Mock <IProductCatalog>();
membershipMoq = new Mock <IMembershipService>();
commissionMoq = new Mock <ICommisionService>();
paymentServiceMoq = new Mock <IPaymentService>();
paymentHandler = new PaymentHandler(
() => { return(packingSlipBuilderMoq.Object); },
productCatalogMoq.Object,
membershipMoq.Object,
commissionMoq.Object);
paymentAccount = new PaymentAccount()
{
Id = 50
};
payment = new Payment()
{
Id = 40,
PaymentAccount = paymentAccount,
Amount = 20.01M
};
productId = 3;
orderId = 100;
order = new Order()
{
OrderId = orderId,
ProductId = productId,
Payment = payment
};
orderRepository = new OrderRepository(paymentHandler,
productCatalogMoq.Object,
paymentServiceMoq.Object);
}
