public PepperiImportHeaderTemp GetTempTableData(ScheduledTask task)
{
PepperiImportHeaderTemp piht = new PepperiImportHeaderTemp();
SalesOrderHeader soHeader = new SalesOrderHeader();
try {
piht = db.FindPepperiImportHeaderTempRecord();
} catch (Exception ex) {
TaskService.WriteTaskLog(task, $"Error: There was an error retreiving data from the TEMP tables - @GetTempTableData" + ex.Message, LogSeverity.Severe);
}
return(piht);
}
// PUT api/awbuildversion/5
public void Put(SalesOrderHeader value)
{
var GetActionType = Request.Headers.Where(x => x.Key.Equals("ActionType")).FirstOrDefault();
if (GetActionType.Key != null)
{
if (GetActionType.Value.ToList()[0].Equals("DELETE"))
adventureWorks_BC.SalesOrderHeaderDelete(value);
if (GetActionType.Value.ToList()[0].Equals("UPDATE"))
adventureWorks_BC.SalesOrderHeaderUpdate(value);
}
}
public List <SalesOrderHeader> CopyTempDataToSalesModel(List <ShopifyImportHeaderTemp> headers, string businessName)
{
List <SalesOrderHeader> soHeaders = new List <SalesOrderHeader>();
foreach (var order in headers)
{
SalesOrderHeader soh = MapTempToSalesOrderHeader(order, businessName);
soh.SalesOrderDetails = MapTempToSalesDetails(order.ShopifyImportDetailTemps);
soHeaders.Add(soh);
}
return(soHeaders);
}
public void Single_Where_AllColumns()
{
var soh = new SalesOrderHeaders();
SalesOrderHeader singleInstance = soh.Single(new { SalesOrderID = 43666 });
Assert.AreEqual(43666, singleInstance.SalesOrderID);
Assert.Greater(singleInstance.CustomerID, 0);
Assert.Greater(singleInstance.SalesPersonID, 0);
Assert.Greater(singleInstance.Status, 0);
Assert.AreNotEqual(singleInstance.PurchaseOrderNumber, "");
Assert.Greater(singleInstance.OrderDate, DateTime.MinValue);
}
public ActionResult Create([Bind(Include = "SalesOrderID,RevisionNumber,OrderDate,DueDate,ShipDate,Status,OnlineOrderFlag,SalesOrderNumber,PurchaseOrderNumber,AccountNumber,CustomerID,SalesPersonID,TerritoryID,BillToAddressID,ShipToAddressID,ShipMethodID,CreditCardID,CreditCardApprovalCode,CurrencyRateID,SubTotal,TaxAmt,Freight,TotalDue,Comment,rowguid,ModifiedDate")] SalesOrderHeader salesOrderHeader)
{
if (ModelState.IsValid)
{
db.SalesOrderHeader.Add(salesOrderHeader);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.SalesPersonID = new SelectList(db.SalesPerson, "BusinessEntityID", "BusinessEntityID", salesOrderHeader.SalesPersonID);
return(View(salesOrderHeader));
}
public void IsValid_SalesPersonIDCheck()
{
var soh = new SalesOrderHeader();
var toValidate = soh.Single(new { SalesOrderID = 45816 });
// is invalid
Assert.AreEqual(1, soh.IsValid(toValidate).Count);
toValidate = soh.Single(new { SalesOrderID = 45069 });
// is valid
Assert.AreEqual(0, soh.IsValid(toValidate).Count);
}
public async Task <IActionResult> PostSalesOrderHeader([FromBody] SalesOrderHeader salesOrderHeader)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.SalesOrderHeader.Add(salesOrderHeader);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetSalesOrderHeader", new { id = salesOrderHeader.SalesOrderHeaderId }, salesOrderHeader));
}
public async Task Single_Key_AllColumns()
{
var soh = new SalesOrderHeaders();
SalesOrderHeader singleInstance = await soh.SingleAsync(43666);
Assert.AreEqual(43666, singleInstance.SalesOrderID);
Assert.Greater(singleInstance.CustomerID, 0);
Assert.Greater(singleInstance.SalesPersonID, 0);
Assert.Greater(singleInstance.Status, 0);
Assert.AreNotEqual(singleInstance.PurchaseOrderNumber, "");
Assert.Greater(singleInstance.OrderDate, DateTime.MinValue);
}
public void Create_new_Product_in_existing_Contact_by_reference()
{
using (var context = new AdventureWorksEntities())
{
SalesOrderHeader order = new SalesOrderHeader
{
SalesOrderID = 1,
ModifiedDate = DateTime.Now,
Contact = context.Contacts.Single(c => c.ContactID == 13)
};
context.SaveChanges();
}
}
private async Task <bool> BeUniqueBySalesOrderNumber(ApiSalesOrderHeaderRequestModel model, CancellationToken cancellationToken)
{
SalesOrderHeader record = await this.salesOrderHeaderRepository.BySalesOrderNumber(model.SalesOrderNumber);
if (record == null || (this.existingRecordId != default(int) && record.SalesOrderID == this.existingRecordId))
{
return(true);
}
else
{
return(false);
}
}
public async Task <ApiSalesOrderHeaderResponseModel> BySalesOrderNumber(string salesOrderNumber)
{
SalesOrderHeader record = await this.salesOrderHeaderRepository.BySalesOrderNumber(salesOrderNumber);
if (record == null)
{
return(null);
}
else
{
return(this.bolSalesOrderHeaderMapper.MapBOToModel(this.dalSalesOrderHeaderMapper.MapEFToBO(record)));
}
}
public async Task All_NoParameters_Streaming()
{
var soh = new SalesOrderHeader();
var allRows = await soh.AllAsync();
var count = 0;
await allRows.ForEachAsync(r => {
count++;
Assert.AreEqual(26, ((IDictionary <string, object>)r).Count); // # of fields fetched should be 26
});
Assert.AreEqual(31465, count);
}
public void Create_new_Product_in_existing_Contact_relate_by_addition_to_collection()
{
using (var context = new AdventureWorksEntities())
{
SalesOrderHeader order = new SalesOrderHeader
{
SalesOrderID = 1,
ModifiedDate = DateTime.Now,
};
context.Contacts.Single(c => c.ContactID == 13).SalesOrderHeaders.Add(order);
context.SaveChanges();
}
}
public async Task All_WhereSpecification_ColumnsSpecification()
{
var soh = new SalesOrderHeader();
var allRows = await(await soh.AllAsync(columns: "SalesOrderID as SOID, Status, SalesPersonID", where : "WHERE CustomerId=@0", args: 30052)).ToListAsync();
Assert.AreEqual(4, allRows.Count);
var firstRow = (IDictionary <string, object>)allRows[0];
Assert.AreEqual(3, firstRow.Count);
Assert.IsTrue(firstRow.ContainsKey("SOID"));
Assert.IsTrue(firstRow.ContainsKey("Status"));
Assert.IsTrue(firstRow.ContainsKey("SalesPersonID"));
}
public void All_ColumnSpecification()
{
var soh = new SalesOrderHeader();
var allRows = soh.All(columns: "SalesOrderID as SOID, Status, SalesPersonID").ToList();
Assert.AreEqual(31465, allRows.Count);
var firstRow = (IDictionary <string, object>)allRows[0];
Assert.AreEqual(3, firstRow.Count);
Assert.IsTrue(firstRow.ContainsKey("SOID"));
Assert.IsTrue(firstRow.ContainsKey("Status"));
Assert.IsTrue(firstRow.ContainsKey("SalesPersonID"));
}
/// <summary>
/// Serialize the mock SalesOrderHeader entity into a temporary file.
/// </summary>
private void Step_06_SerializeEntity_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
mock = CreateMockInstance(tm);
string fileName = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "temp_SalesOrderHeader.xml");
EntityHelper.SerializeXml(mock, fileName);
Assert.IsTrue(System.IO.File.Exists(fileName), "Serialized mock not found");
System.Console.WriteLine("mock correctly serialized to a temporary file.");
}
}
public void All_WhereSpecification_ColumnsSpecification_LimitSpecification()
{
var soh = new SalesOrderHeader();
var allRows = soh.All(limit: 2, columns: "SalesOrderID as SOID, Status, SalesPersonID", where : "WHERE CustomerId=@0", args: 30052).ToList();
Assert.AreEqual(2, allRows.Count);
var firstRow = (IDictionary <string, object>)allRows[0];
Assert.AreEqual(3, firstRow.Count);
Assert.IsTrue(firstRow.ContainsKey("SOID"));
Assert.IsTrue(firstRow.ContainsKey("Status"));
Assert.IsTrue(firstRow.ContainsKey("SalesPersonID"));
}
public void All_NoParameters_Streaming()
{
var soh = new SalesOrderHeader();
var allRows = soh.All();
var count = 0;
foreach (var r in allRows)
{
count++;
Assert.AreEqual(26, ((IDictionary <string, object>)r).Count); // # of fields fetched should be 26
}
Assert.AreEqual(31465, count);
}
private async Task <DialogTurnResult> ActStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
if (!_luisRecognizer.IsConfigured)
{
// LUIS is not configured, we just run the ShowOrdersDialog path with an empty BookingDetailsInstance.
return(await stepContext.BeginDialogAsync(nameof(ShowOrdersDialog), cancellationToken));
}
// Call LUIS and gather any potential booking details. (Note the TurnContext has the response to the prompt.)
var luisResult = await _luisRecognizer.RecognizeAsync <SmartTrade>(stepContext.Context, cancellationToken);
switch (luisResult.TopIntent().intent)
{
case SmartTrade.Intent.getCustomer:
//var response = client.GetAsync("api/SmartTradeApi/GetCustomer?customerId=29847").Result;
//if (response.IsSuccessStatusCode)
//{
// string responseString = response.Content.ReadAsStringAsync().Result;
//}
//IEnumerable<Customer> customer = response.Content.ReadAsAsync<IEnumerable<Customer>>().Result;
var customer = new Customer();
return(await stepContext.BeginDialogAsync(nameof(ShowOrdersDialog), customer, cancellationToken));
case SmartTrade.Intent.getSalesByCustomer:
//await ShowWarningForUnsupportedCities(stepContext.Context, luisResult, cancellationToken);
// Initialize BookingDetails with any entities we may have found in the response.
var salesOrderHeader = new SalesOrderHeader();
//{
// // Get destination and origin from the composite entities arrays.
// CustomerID = luisResult.Entities.sales;
//};
// Run the ShowOrdersDialog giving it whatever details we have from the LUIS call, it will fill out the remainder.
return(await stepContext.BeginDialogAsync(nameof(ShowOrdersDialog), salesOrderHeader, cancellationToken));
default:
// Catch all for unhandled intents
var didntUnderstandMessageText = $"Sorry, I didn't get that. Please try asking in a different way (intent was {luisResult.TopIntent().intent})";
var didntUnderstandMessage = MessageFactory.Text(didntUnderstandMessageText, didntUnderstandMessageText, InputHints.IgnoringInput);
await stepContext.Context.SendActivityAsync(didntUnderstandMessage, cancellationToken);
break;
}
return(await stepContext.NextAsync(null, cancellationToken));
}
public async Task All_ColumnSpecification()
{
// specify columns a different way to cause a cache miss
var soh = new SalesOrderHeader(columns: "SalesOrderID as SOID, Status, SalesPersonID");
var allRows = await(await soh.AllAsync()).ToListAsync();
Assert.AreEqual(31465, allRows.Count);
var firstRow = (IDictionary <string, object>)allRows[0];
Assert.AreEqual(3, firstRow.Count);
Assert.IsTrue(firstRow.ContainsKey("SOID"));
Assert.IsTrue(firstRow.ContainsKey("Status"));
Assert.IsTrue(firstRow.ContainsKey("SalesPersonID"));
}
public void Create_new_Product_in_existing_Contact_by_value()
{
using (var context = new AdventureWorksEntities())
{
SalesOrderHeader order = new SalesOrderHeader
{
SalesOrderID = 1,
ModifiedDate = DateTime.Now,
ContactID = 13
};
context.SalesOrderHeaders.AddObject(order);
context.SaveChanges();
}
}
public void MapEFToBOList()
{
var mapper = new DALSalesOrderHeaderMapper();
SalesOrderHeader entity = new SalesOrderHeader();
entity.SetProperties("A", 1, "A", "A", 1, 1, 1, DateTime.Parse("1/1/1987 12:00:00 AM"), 1m, DateTime.Parse("1/1/1987 12:00:00 AM"), true, DateTime.Parse("1/1/1987 12:00:00 AM"), "A", 1, Guid.Parse("8420cdcf-d595-ef65-66e7-dff9f98764da"), 1, "A", 1, DateTime.Parse("1/1/1987 12:00:00 AM"), 1, 1, 1, 1m, 1m, 1, 1m);
List <BOSalesOrderHeader> response = mapper.MapEFToBO(new List <SalesOrderHeader>()
{
entity
});
response.Count.Should().Be(1);
}
public SalesOrderHeader CreateOrder()
{
SalesOrderHeader soh = OrderRepo.CreateNewOrder(Customer, true);
soh.Status = (byte)OrderStatus.InProcess;
Container.Persist(ref soh);
foreach (OrderLine d in Details)
{
d.AddTo(soh);
}
return(soh);
}
public bool SalesOrderHeaderDelete(SalesOrderHeader salesorderheader)
{
return(Execute <bool>(dal =>
{
SalesOrderHeader salesorderheaderDelete = dal.SalesOrderHeader.Where(x => x.SalesOrderID == salesorderheader.SalesOrderID).FirstOrDefault();
if (salesorderheaderDelete != null)
{
dal.SalesOrderHeader.DeleteOnSubmit(salesorderheaderDelete);
dal.SubmitChanges();
return true;
}
return false;
}));
}
public void IsValid_SalesPersonIDCheck()
{
dynamic soh = new SalesOrderHeader();
var toValidate = soh.Find(SalesOrderID: 45816);
// is invalid
Assert.IsFalse(soh.IsValid(toValidate));
Assert.AreEqual(1, soh.Errors.Count);
toValidate = soh.Find(SalesOrderID: 45069);
// is valid
Assert.IsTrue(soh.IsValid(toValidate));
Assert.AreEqual(0, soh.Errors.Count);
}
public void UnsafeExpressionsShouldPass(string unsafeExpression, Func <IUserDefinedExpression, ISafetyValidator> validatorFactory)
{
var order1 = new SalesOrderHeader()
{
DueDate = DateTime.Today.AddDays(-1)
};
UserDefinedExpression.DefaultSafetyValidatorFactory = validatorFactory;
Assert.DoesNotThrow(() =>
{
var unsafeUDE = UserDefinedExpression <SalesOrderHeader, bool> .Create(unsafeExpression);
bool result = unsafeUDE.Invoke(order1);
});
}
public bool SalesOrderHeaderExists(SalesOrderHeader salesOrderHeader)
{
try
{
return(_ctx.SalesOrderHeaders.Any(c =>
c.SalesOrderNo == salesOrderHeader.SalesOrderNo &&
c.SalesOrderId != salesOrderHeader.SalesOrderId));
}
catch (Exception ex)
{
_logger.LogError($"Failed in SalesOrderHeaderExists: {ex}");
return(false);
}
}
public IHttpActionResult DeleteSalesOrderHeader(int id)
{
SalesOrderHeader salesOrderHeader = db.SalesOrderHeaders.Find(id);
if (salesOrderHeader == null)
{
return(NotFound());
}
db.SalesOrderHeaders.Remove(salesOrderHeader);
db.SaveChanges();
return(Ok(salesOrderHeader));
}
public ViewResult Edit(int id)
{
EditSalesOrderViewModel viewModel = new EditSalesOrderViewModel();
viewModel.IsEdit = true;
SalesOrderHeader so = _salesService.GetSalesOrder(id);
viewModel.SO = SalesModelConverter.ConverToModel(so);
// details
viewModel.SODetails = SalesModelConverter.ConverToModel(so.SalesOrderDetails);
return(View("EditSalesOrder", viewModel));
}
// DELETE: odata/SalesOrderHeaders(5)
public async Task <IHttpActionResult> Delete([FromODataUri] int key)
{
SalesOrderHeader salesOrderHeader = await db.SalesOrderHeaders.FindAsync(key);
if (salesOrderHeader == null)
{
return(NotFound());
}
db.SalesOrderHeaders.Remove(salesOrderHeader);
await db.SaveChangesAsync();
return(StatusCode(HttpStatusCode.NoContent));
}
// GET: SalesOrderHeaders/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SalesOrderHeader salesOrderHeader = db.SalesOrderHeader.Find(id);
if (salesOrderHeader == null)
{
return(HttpNotFound());
}
return(View(salesOrderHeader));
}
/// <summary>
/// Inserts a mock SalesOrderHeader entity into the database.
/// </summary>
private void Step_01_Insert_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
mock = CreateMockInstance(tm);
Assert.IsTrue(DataRepository.SalesOrderHeaderProvider.Insert(tm, mock), "Insert failed");
System.Console.WriteLine("DataRepository.SalesOrderHeaderProvider.Insert(mock):");
System.Console.WriteLine(mock);
//normally one would commit here
//tm.Commit();
//IDisposable will Rollback Transaction since it's left uncommitted
}
}
public async Task<IHttpActionResult> PostOrder(int productId, string userName)
{
Customer customer = await repository.Customers.FirstOrDefaultAsync(x => x.EmailAddress == userName);
if (!customer.SalesOrderHeaders.Any() || customer.SalesOrderHeaders.All(x => x.Status == 0))
{
var salesOrderHeader = new SalesOrderHeader
{
Address = customer.CustomerAddresses.First().Address,
OrderDate = DateTime.Now,
DueDate = DateTime.MaxValue,
Status = 1,
Customer = customer,
ShipMethod = string.Empty,
rowguid = Guid.NewGuid(),
ModifiedDate = DateTime.Now,
SalesOrderDetails = new List<SalesOrderDetail>(),
CustomerID = customer.CustomerID,
};
customer.SalesOrderHeaders.Add(salesOrderHeader);
}
SalesOrderHeader currentOrder = customer.SalesOrderHeaders.Last(x => x.Status == 1);
if (currentOrder.SalesOrderDetails.All(x => x.Product.ProductID != productId))
{
var product = repository.Products.First(x => x.ProductID == productId);
var salesOrderDetail = new SalesOrderDetail
{
Product = product,
SalesOrderHeader = currentOrder,
ModifiedDate = DateTime.Now,
rowguid = Guid.NewGuid(),
LineTotal = 0,
UnitPrice = product.ListPrice,
ProductID = productId,
UnitPriceDiscount = 0,
OrderQty = ((short)1)
};
currentOrder.SalesOrderDetails.Add(salesOrderDetail);
product.SalesOrderDetails.Add(salesOrderDetail);
await repository.SaveChangesAsync();
}
return CreatedAtRoute("DefaultApi", new {id = productId}, productId);
}
public static SalesOrderHeader CreateSalesOrderHeader(int salesOrderID, byte revisionNumber, global::System.DateTime orderDate, global::System.DateTime dueDate, byte status, bool onlineOrderFlag, string salesOrderNumber, int customerID, string shipMethod, decimal subTotal, decimal taxAmt, decimal freight, decimal totalDue, global::System.Guid rowguid, global::System.DateTime modifiedDate)
{
SalesOrderHeader salesOrderHeader = new SalesOrderHeader();
salesOrderHeader.SalesOrderID = salesOrderID;
salesOrderHeader.RevisionNumber = revisionNumber;
salesOrderHeader.OrderDate = orderDate;
salesOrderHeader.DueDate = dueDate;
salesOrderHeader.Status = status;
salesOrderHeader.OnlineOrderFlag = onlineOrderFlag;
salesOrderHeader.SalesOrderNumber = salesOrderNumber;
salesOrderHeader.CustomerID = customerID;
salesOrderHeader.ShipMethod = shipMethod;
salesOrderHeader.SubTotal = subTotal;
salesOrderHeader.TaxAmt = taxAmt;
salesOrderHeader.Freight = freight;
salesOrderHeader.TotalDue = totalDue;
salesOrderHeader.rowguid = rowguid;
salesOrderHeader.ModifiedDate = modifiedDate;
return salesOrderHeader;
}
public void AddSalesOrderHeader(SalesOrderHeader salesOrderHeader)
{
_context.Entry(salesOrderHeader).State = salesOrderHeader.SalesOrderID==0?EntityState.Added:EntityState.Modified;
_context.SaveChanges();
}
// POST api/awbuildversion
public void Post(SalesOrderHeader value)
{
adventureWorks_BC.SalesOrderHeaderAdd(value);
}
/// <summary>
/// Serialize the mock SalesOrderHeader entity into a temporary file.
/// </summary>
private void Step_06_SerializeEntity_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
mock = CreateMockInstance(tm);
string fileName = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "temp_SalesOrderHeader.xml");
EntityHelper.SerializeXml(mock, fileName);
Assert.IsTrue(System.IO.File.Exists(fileName), "Serialized mock not found");
System.Console.WriteLine("mock correctly serialized to a temporary file.");
}
}
/// <summary>
/// Create a new SalesOrderHeader object.
/// </summary>
/// <param name="status">Initial value of Status.</param>
/// <param name="subTotal">Initial value of SubTotal.</param>
/// <param name="totalDue">Initial value of TotalDue.</param>
/// <param name="bookCounter">Initial value of BookCounter.</param>
/// <param name="subSubTotal">Initial value of SubSubTotal.</param>
/// <param name="priceRabatt15">Initial value of PriceRabatt15.</param>
/// <param name="total">Initial value of Total.</param>
/// <param name="discount">Initial value of Discount.</param>
/// <param name="rabatt">Initial value of Rabatt.</param>
/// <param name="id">Initial value of ID.</param>
/// <param name="saison">Initial value of Saison.</param>
public static SalesOrderHeader CreateSalesOrderHeader(int status, decimal subTotal, decimal totalDue, int bookCounter, decimal subSubTotal, bool priceRabatt15, decimal total, decimal discount, decimal rabatt, int id, string saison)
{
SalesOrderHeader salesOrderHeader = new SalesOrderHeader();
salesOrderHeader.Status = status;
salesOrderHeader.SubTotal = subTotal;
salesOrderHeader.TotalDue = totalDue;
salesOrderHeader.BookCounter = bookCounter;
salesOrderHeader.SubSubTotal = subSubTotal;
salesOrderHeader.PriceRabatt15 = priceRabatt15;
salesOrderHeader.Total = total;
salesOrderHeader.Discount = discount;
salesOrderHeader.Rabatt = rabatt;
salesOrderHeader.ID = id;
salesOrderHeader.Saison = saison;
return salesOrderHeader;
}
private void attach_SalesOrderHeaders(SalesOrderHeader entity)
{
this.SendPropertyChanging();
entity.Address = this;
}
/// <summary>
/// Serialize a SalesOrderHeader collection into a temporary file.
/// </summary>
private void Step_08_SerializeCollection_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
string fileName = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "temp_SalesOrderHeaderCollection.xml");
mock = CreateMockInstance(tm);
TList<SalesOrderHeader> mockCollection = new TList<SalesOrderHeader>();
mockCollection.Add(mock);
EntityHelper.SerializeXml(mockCollection, fileName);
Assert.IsTrue(System.IO.File.Exists(fileName), "Serialized mock collection not found");
System.Console.WriteLine("TList<SalesOrderHeader> correctly serialized to a temporary file.");
}
}
/// <summary>
/// Test methods exposed by the EntityHelper class.
/// </summary>
private void Step_20_TestEntityHelper_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
mock = CreateMockInstance(tm);
SalesOrderHeader entity = mock.Copy() as SalesOrderHeader;
entity = (SalesOrderHeader)mock.Clone();
Assert.IsTrue(SalesOrderHeader.ValueEquals(entity, mock), "Clone is not working");
}
}
partial void DeleteSalesOrderHeader(SalesOrderHeader instance);
partial void UpdateSalesOrderHeader(SalesOrderHeader instance);
partial void InsertSalesOrderHeader(SalesOrderHeader instance);
private void detach_SalesOrderHeaders1(SalesOrderHeader entity)
{
this.SendPropertyChanging();
entity.Address1 = null;
}
///<summary>
/// Update the Typed SalesOrderHeader Entity with modified mock values.
///</summary>
static public void UpdateMockInstance(TransactionManager tm, SalesOrderHeader mock)
{
SalesOrderHeaderTest.UpdateMockInstance_Generated(tm, mock);
// make any alterations necessary
// (i.e. for DB check constraints, special test cases, etc.)
SetSpecialTestData(mock);
}
private void detach_SalesOrderHeaders(SalesOrderHeader entity)
{
this.SendPropertyChanging();
entity.Customer = null;
}
public void AddTo(SalesOrderHeader salesOrder) {
SalesOrderDetail sod = salesOrder.AddNewDetail(Product, Number);
Container.Persist(ref sod);
}
private void attach_SalesOrderHeader(SalesOrderHeader entity)
{
this.SendPropertyChanging();
entity.Customer = this;
}
///<summary>
/// Update the Typed SalesOrderHeader Entity with modified mock values.
///</summary>
static public void UpdateMockInstance_Generated(TransactionManager tm, SalesOrderHeader mock)
{
mock.RevisionNumber = TestUtility.Instance.RandomByte();
mock.OrderDate = TestUtility.Instance.RandomDateTime();
mock.DueDate = TestUtility.Instance.RandomDateTime();
mock.ShipDate = TestUtility.Instance.RandomDateTime();
mock.Status = TestUtility.Instance.RandomByte();
mock.OnlineOrderFlag = TestUtility.Instance.RandomBoolean();
mock.PurchaseOrderNumber = TestUtility.Instance.RandomString(11, false);;
mock.AccountNumber = TestUtility.Instance.RandomString(6, false);;
mock.CreditCardApprovalCode = TestUtility.Instance.RandomString(6, false);;
mock.SubTotal = TestUtility.Instance.RandomShort();
mock.TaxAmt = TestUtility.Instance.RandomShort();
mock.Freight = TestUtility.Instance.RandomShort();
mock.Comment = TestUtility.Instance.RandomString(63, false);;
mock.ModifiedDate = TestUtility.Instance.RandomDateTime();
int count0 = 0;
TList<Address> _collection0 = DataRepository.AddressProvider.GetPaged(tm, 0, 10, out count0);
//_collection0.Shuffle();
if (_collection0.Count > 0)
{
mock.BillToAddressId = _collection0[0].AddressId;
}
int count1 = 0;
TList<Address> _collection1 = DataRepository.AddressProvider.GetPaged(tm, 0, 10, out count1);
//_collection1.Shuffle();
if (_collection1.Count > 0)
{
mock.ShipToAddressId = _collection1[0].AddressId;
}
int count2 = 0;
TList<Contact> _collection2 = DataRepository.ContactProvider.GetPaged(tm, 0, 10, out count2);
//_collection2.Shuffle();
if (_collection2.Count > 0)
{
mock.ContactId = _collection2[0].ContactId;
}
int count3 = 0;
TList<CreditCard> _collection3 = DataRepository.CreditCardProvider.GetPaged(tm, 0, 10, out count3);
//_collection3.Shuffle();
if (_collection3.Count > 0)
{
mock.CreditCardId = _collection3[0].CreditCardId;
}
int count4 = 0;
TList<CurrencyRate> _collection4 = DataRepository.CurrencyRateProvider.GetPaged(tm, 0, 10, out count4);
//_collection4.Shuffle();
if (_collection4.Count > 0)
{
mock.CurrencyRateId = _collection4[0].CurrencyRateId;
}
int count5 = 0;
TList<Customer> _collection5 = DataRepository.CustomerProvider.GetPaged(tm, 0, 10, out count5);
//_collection5.Shuffle();
if (_collection5.Count > 0)
{
mock.CustomerId = _collection5[0].CustomerId;
}
int count6 = 0;
TList<SalesPerson> _collection6 = DataRepository.SalesPersonProvider.GetPaged(tm, 0, 10, out count6);
//_collection6.Shuffle();
if (_collection6.Count > 0)
{
mock.SalesPersonId = _collection6[0].SalesPersonId;
}
int count7 = 0;
TList<SalesTerritory> _collection7 = DataRepository.SalesTerritoryProvider.GetPaged(tm, 0, 10, out count7);
//_collection7.Shuffle();
if (_collection7.Count > 0)
{
mock.TerritoryId = _collection7[0].TerritoryId;
}
int count8 = 0;
TList<ShipMethod> _collection8 = DataRepository.ShipMethodProvider.GetPaged(tm, 0, 10, out count8);
//_collection8.Shuffle();
if (_collection8.Count > 0)
{
mock.ShipMethodId = _collection8[0].ShipMethodId;
}
}
/// <summary>
/// Make any alterations necessary (i.e. for DB check constraints, special test cases, etc.)
/// </summary>
/// <param name="mock">Object to be modified</param>
static private void SetSpecialTestData(SalesOrderHeader mock)
{
//Code your changes to the data object here.
mock.DueDate = mock.OrderDate.AddDays(1);
mock.ShipDate = mock.OrderDate.AddDays(1);
mock.Status = TestUtility.Instance.RandomByte(1, 8);
mock.SubTotal = TestUtility.Instance.RandomNumber(0, 100);
}
/// <summary>
/// There are no comments for SalesOrderHeader in the schema.
/// </summary>
public void AddToSalesOrderHeader(SalesOrderHeader salesOrderHeader)
{
base.AddObject("SalesOrderHeader", salesOrderHeader);
}
/// <summary>
/// Deep load all SalesOrderHeader children.
/// </summary>
private void Step_03_DeepLoad_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
int count = -1;
mock = CreateMockInstance(tm);
mockCollection = DataRepository.SalesOrderHeaderProvider.GetPaged(tm, 0, 10, out count);
DataRepository.SalesOrderHeaderProvider.DeepLoading += new EntityProviderBaseCore<SalesOrderHeader, SalesOrderHeaderKey>.DeepLoadingEventHandler(
delegate(object sender, DeepSessionEventArgs e)
{
if (e.DeepSession.Count > 3)
e.Cancel = true;
}
);
if (mockCollection.Count > 0)
{
DataRepository.SalesOrderHeaderProvider.DeepLoad(tm, mockCollection[0]);
System.Console.WriteLine("SalesOrderHeader instance correctly deep loaded at 1 level.");
mockCollection.Add(mock);
// DataRepository.SalesOrderHeaderProvider.DeepSave(tm, mockCollection);
}
//normally one would commit here
//tm.Commit();
//IDisposable will Rollback Transaction since it's left uncommitted
}
}
