public void RollbackDeletionWithRelationChange()
{
Order order = DomainObjectIDs.Order1.GetObject <Order> ();
OrderTicket oldOrderTicket = order.OrderTicket;
DomainObjectCollection oldOrderItems = order.GetOriginalRelatedObjects("Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.OrderItems");
Customer oldCustomer = order.Customer;
Official oldOfficial = order.Official;
order.Delete();
Assert.That(order.OrderTicket, Is.Null);
Assert.That(order.OrderItems.Count, Is.EqualTo(0));
Assert.That(order.Customer, Is.Null);
Assert.That(order.Official, Is.Null);
TestableClientTransaction.Rollback();
Assert.That(order.OrderTicket, Is.SameAs(oldOrderTicket));
Assert.That(order.OrderItems.Count, Is.EqualTo(oldOrderItems.Count));
Assert.That(order.OrderItems[DomainObjectIDs.OrderItem1], Is.SameAs(oldOrderItems[DomainObjectIDs.OrderItem1]));
Assert.That(order.OrderItems[DomainObjectIDs.OrderItem2], Is.SameAs(oldOrderItems[DomainObjectIDs.OrderItem2]));
Assert.That(order.Customer, Is.SameAs(oldCustomer));
Assert.That(order.Official, Is.SameAs(oldOfficial));
}
public void CommittedRelatedObjectCollectionOrder()
{
Order order = Order.NewObject();
Official official = DomainObjectIDs.Official1.GetObject <Official>();
order.Official = official;
order.Customer = DomainObjectIDs.Customer1.GetObject <Customer> ();
OrderItem orderItem1 = OrderItem.NewObject();
OrderItem orderItem2 = OrderItem.NewObject();
OrderItem orderItem3 = OrderItem.NewObject();
order.OrderItems.Add(orderItem1);
order.OrderItems.Add(orderItem2);
order.OrderItems.Add(orderItem3);
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
Assert.That(order.OrderItems, Is.EqualTo(new object[] { orderItem1, orderItem2, orderItem3 }));
order.OrderItems.Clear();
order.OrderItems.Add(orderItem2);
order.OrderItems.Add(orderItem3);
order.OrderItems.Add(orderItem1);
Assert.That(order.OrderItems, Is.EqualTo(new object[] { orderItem2, orderItem3, orderItem1 }));
ClientTransaction.Current.Commit();
Assert.That(order.OrderItems, Is.EqualTo(new object[] { orderItem2, orderItem3, orderItem1 }));
}
Assert.That(order.OrderItems, Is.EqualTo(new object[] { orderItem2, orderItem3, orderItem1 }));
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
Assert.That(order.OrderItems, Is.EqualTo(new object[] { orderItem2, orderItem3, orderItem1 }));
}
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id,Name,Position,MunicipalityId")] Official official)
{
if (id != official.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(official);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OfficialExists(official.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(official));
}
public void CommitSubTransaction()
{
_customer.Orders.EnsureDataComplete();
var orderCollection = _customer.Orders;
_eventReceiverMock
.Expect(mock => mock.OnReplaceData())
.WhenCalled(mi => Assert.That(orderCollection.Count, Is.EqualTo(3)));
_eventReceiverMock.Replay();
_customer.Orders.SetEventReceiver(_eventReceiverMock);
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var newOrder = Order.NewObject();
newOrder.OrderTicket = OrderTicket.NewObject();
newOrder.OrderItems.Add(OrderItem.NewObject());
newOrder.Official = Official.NewObject();
_customer.Orders.Add(newOrder);
ClientTransaction.Current.Commit();
}
_eventReceiverMock.VerifyAllExpectations();
}
private void btnSave_Click(object sender, RoutedEventArgs e)
{
try
{
Official objOfficial = new Official();
ObservableCollection<Official> lbxOfficial = Database.GetEntityList<Official>(false, false, false, Database.getReadConnection(), "RecordStatus", "OfficialId");
foreach (Official objoff in lbxOfficial)
{
if (objoff.OfficialId.ToString() == updateUmpire.umpireid)
{
objOfficial.OfficialId = (Guid.Parse(updateUmpire.umpireid));
objOfficial.OfficialName = txtName.Text;
objOfficial.EmailId = txtemailid.Text;
objOfficial.MobileNo = txtmobno.Text;
objOfficial.DateOfBirth = dateselect.SelectedDate.Value;
objOfficial.OfficialPrimaryId = txtId.Text;
objOfficial.Place = txtPlace.Text;
Zone objZone = Database.GetEntity<Zone>(Guid.Parse(cbxZone.SelectedValue.ToString()), false, false, false, Database.getConnection());
objOfficial.Zone = objZone;
//Gender Select
if (rbtnmale.IsChecked == true)
{
objOfficial.Gender = "Male";
}
else if (rbtnfemale.IsChecked == true)
{
objOfficial.Gender = "Female";
}
else
{
MessageBox.Show("Select Gender");
}
//FileStream fs = new FileStream(txt_browse.Text, FileMode.OpenOrCreate, FileAccess.Read);
//byte[] rawData = new byte[fs.Length];
//fs.Read(rawData, 0, System.Convert.ToInt32(fs.Length));
//fs.Close();
//objOfficial.PlayerImage = rawData;
break;
}
}
Database.SaveEntity<Official>(objOfficial, Database.getConnection());
MessageBox.Show("Official Updated");
}
catch (Exception ex)
{
throw ex;
}
}
public void ChangedComittedQueriedObjectsCanBeUsedInParentTransaction()
{
IQueryResult queriedObjects;
Customer queriedObject;
Order newOrder;
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var query = QueryFactory.CreateQueryFromConfiguration("CustomerTypeQuery");
query.Parameters.Add("@customerType", Customer.CustomerType.Standard);
queriedObjects = ClientTransactionScope.CurrentTransaction.QueryManager.GetCollection(query);
queriedObject = (Customer)queriedObjects.ToArray() [0];
newOrder = Order.NewObject();
newOrder.Official = Official.NewObject();
newOrder.OrderTicket = OrderTicket.NewObject();
newOrder.OrderItems.Add(OrderItem.NewObject());
queriedObject.Orders.Insert(0, newOrder);
queriedObject.CustomerSince = null;
ClientTransactionScope.CurrentTransaction.Commit();
}
Assert.That(queriedObjects, Is.Not.Null);
Assert.That(queriedObjects.Count, Is.EqualTo(1));
Assert.That(queriedObjects.ToArray()[0].ID, Is.EqualTo(DomainObjectIDs.Customer1));
Assert.That(queriedObject.CustomerSince, Is.Null);
Assert.That(queriedObject.Orders[0], Is.SameAs(newOrder));
}
public static bool UpdateOfficial(Official official)
{
DBConnection connection = new DBConnection();
connection.OpenConection();
SqlCommand command = connection.CreateCommand(updateOfficial);
command.Parameters.AddWithValue("@Name", official.Name);
command.Parameters.AddWithValue("@Surname", official.SurName);
command.Parameters.AddWithValue("@Mail", official.Mail);
command.Parameters.AddWithValue("@Phone", official.Phone);
command.Parameters.AddWithValue("@AddressId", official.Address.Id);
command.Parameters.AddWithValue("@OfficialType", official.OfficialType);
command.Parameters.AddWithValue("@CompanyNumber", official.CompanyNumber);
int result = command.ExecuteNonQuery();
connection.CloseConnection();
if (result == 1)
{
return(true);
}
return(false);
}
public static bool CreateNewOfficial(Official official)
{
//if (!CreateAddress(official.Address))
// return false;
DBConnection connection = new DBConnection();
connection.OpenConection();
SqlCommand command = connection.CreateCommand(createOfficial);
command.Parameters.AddWithValue("@GUID", official.Guid);
command.Parameters.AddWithValue("@Name", official.Name);
command.Parameters.AddWithValue("@Surname", official.SurName);
command.Parameters.AddWithValue("@Address", official.Address.Id);
command.Parameters.AddWithValue("@Mail", official.Mail);
command.Parameters.AddWithValue("@Phone", official.Phone);
command.Parameters.AddWithValue("@Valid", official.Valid);
command.Parameters.AddWithValue("@Password", official.Password);
command.Parameters.AddWithValue("@OfficialType", official.OfficialType);
command.Parameters.AddWithValue("@CompanyNumber", official.CompanyNumber);
int result = command.ExecuteNonQuery();
connection.CloseConnection();
if (result == 1)
{
return(true);
}
return(false);
}
public static List <Official> GetAllOfficials()
{
DBConnection connection = new DBConnection();
connection.OpenConection();
SqlCommand command = connection.CreateCommand(selectOfficials);
SqlDataReader reader = command.ExecuteReader();
List <Official> officials = new List <Official>();
while (reader.Read())
{
Official official = new Official();
official.Guid = reader.GetGuid(0);
official.Name = reader.GetString(1);
official.SurName = reader.GetString(2);
official.Address = new Address();
official.Address.Id = reader.GetInt32(3);
official.Mail = reader.GetString(4);
official.Phone = reader.GetString(5);
official.Valid = reader.GetBoolean(6);
official.OfficialType = (OfficialType)reader.GetInt32(7);
official.CompanyNumber = reader.GetString(8);
official.Password = reader.GetString(10);
officials.Add(official);
}
return(officials);
}
public ProductWindow(Official official, Bill bill)
{
activeOfficial = official;
activeBill = bill;
InitializeComponent();
SetDefaultSettings();
}
public ActionResult DeleteConfirmed(int id)
{
Official official = db.Officials.Find(id);
db.Officials.Remove(official);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void CommitSavesRelatedObjectsToParentTransaction()
{
Order order = Order.NewObject();
Official official = DomainObjectIDs.Official1.GetObject <Official>();
order.Official = official;
order.Customer = DomainObjectIDs.Customer1.GetObject <Customer> ();
OrderItem orderItem = OrderItem.NewObject();
order.OrderItems.Add(orderItem);
Assert.That(order.Official, Is.SameAs(official));
Assert.That(order.OrderItems.Count, Is.EqualTo(1));
Assert.That(order.OrderItems.ContainsObject(orderItem), Is.True);
Assert.That(order.OrderTicket, Is.Null);
OrderItem newOrderItem;
OrderTicket newOrderTicket;
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
newOrderItem = OrderItem.NewObject();
orderItem.Delete();
order.OrderItems.Add(newOrderItem);
order.OrderItems.Add(OrderItem.NewObject());
newOrderTicket = OrderTicket.NewObject();
order.OrderTicket = newOrderTicket;
Assert.That(order.Official, Is.SameAs(official));
Assert.That(order.OrderItems.Count, Is.EqualTo(2));
Assert.That(order.OrderItems.ContainsObject(orderItem), Is.False);
Assert.That(order.OrderItems.ContainsObject(newOrderItem), Is.True);
Assert.That(order.OrderTicket, Is.Not.Null);
Assert.That(order.OrderTicket, Is.SameAs(newOrderTicket));
ClientTransactionScope.CurrentTransaction.Commit();
Assert.That(order.State, Is.EqualTo(StateType.Unchanged));
Assert.That(order.Official, Is.SameAs(official));
Assert.That(order.OrderItems.Count, Is.EqualTo(2));
Assert.That(order.OrderItems.ContainsObject(orderItem), Is.False);
Assert.That(order.OrderItems.ContainsObject(newOrderItem), Is.True);
Assert.That(order.OrderTicket, Is.Not.Null);
Assert.That(order.OrderTicket, Is.SameAs(newOrderTicket));
}
Assert.That(order.Official, Is.SameAs(official));
Assert.That(order.OrderItems.Count, Is.EqualTo(2));
Assert.That(order.OrderItems.ContainsObject(orderItem), Is.False);
Assert.That(order.OrderItems.ContainsObject(newOrderItem), Is.True);
Assert.That(order.OrderTicket, Is.Not.Null);
Assert.That(order.OrderTicket, Is.SameAs(newOrderTicket));
}
public IActionResult AddBurial(Official m)
{
var rand = new Random();
m.Burialid = rand.Next();
context.Officials.Add(m);
context.SaveChanges();
return(View("ChangesConfirmed"));
}
public static (List <CareerProperties>, string playerUrl, string playerFound) GetCareerNoSeason(
string lookUpPlayer)
{
var leagueId = 0;
var web = new HtmlWeb();
try
{
var dbPath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
var dbFolder = "Database/";
var dbDir = Path.Combine(dbPath, dbFolder);
using var playerDatabase = new LiteDatabase($"Filename={dbDir}LGFA.db;connection=shared");
var player = playerDatabase.GetCollection <PlayerProperties.PlayerInfo>("Players");
player.EnsureIndex(x => x.playerName);
var result = player.Query()
.Where(x => x.playerName.Contains(lookUpPlayer))
.ToList();
foreach (var found in result)
{
if (found.System == "psn")
{
leagueId = 73;
}
else if (found.System == "xbox")
{
leagueId = 53;
}
try
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var playerDoc = web.Load(found.playerUrl);
stopWatch.Stop();
Log.Logger.Warning($"GetCareerNoSeason Doc: {stopWatch.Elapsed}");
var(table, playerUrl, playerFound) = Official.OfficialParse(playerDoc, found.playerUrl,
found.playerName, leagueId);
return(table, playerUrl, playerFound);
}
catch (Exception e)
{
Log.Logger.Warning($"{found.playerName} in GetCareerNoSeason: {e}");
throw;
}
}
}
catch (Exception e)
{
Log.Logger.Error($"Exception thrown: {e}");
return(null, null, null);
}
return(null, null, null);
}
Official GetRevicedOfficial()
{ // тоже что и SignerDetails
Official ret = new Official();
ret.FirstName = SignerFirstName;
ret.Surname = SignerSureName;
ret.Patronymic = SignerPatronimic;
ret.JobTitle = RcvJobTitle;
return(ret);
}
private Order GetTestGraph()
{
Order root = Order.NewObject();
root.Official = Official.NewObject();
root.OrderTicket = OrderTicket.NewObject();
root.OrderItems.Add(OrderItem.NewObject());
root.OrderItems.Add(OrderItem.NewObject());
root.Customer = Customer.NewObject();
root.Customer.Ceo = Ceo.NewObject();
return(root);
}
public static Official GetOfficialById(string companyNumber)
{
int count = 0;
DBConnection connection = new DBConnection();
connection.OpenConection();
SqlCommand command = connection.CreateCommand(selectByCompanyNumber);
command.Parameters.AddWithValue("@CompanyNumber", companyNumber);
SqlCommand commandCount = connection.CreateCommand(selectCountbyCompanyNumber);
commandCount.Parameters.AddWithValue("@CompanyNumber", companyNumber);
count = (int)commandCount.ExecuteScalar();
SqlDataReader reader = command.ExecuteReader();
Official official = new Official();
switch (count)
{
case 0:
MessageBox.Show("Zadaný úředník neexistuje");
connection.CloseConnection();
return(null);
case 1:
while (reader.Read())
{
official.Guid = reader.GetGuid(0);
official.Name = reader.GetString(1);
official.SurName = reader.GetString(2);
official.Address = new Address();
official.Address.Id = reader.GetInt32(3);
official.Mail = reader.GetString(4);
official.Phone = reader.GetString(5);
official.Valid = reader.GetBoolean(6);
official.OfficialType = (OfficialType)reader.GetInt32(7); //GetInt32 vrací číselnou hodnotu a (OfficialType) to přetypuje na ten správný typ
official.CompanyNumber = reader.GetString(8);
official.Password = reader.GetString(10);
}
connection.CloseConnection();
return(official);
default:
MessageBox.Show("v DB existuje více uživatelů se stéjným ID! ");
return(null);
}
}
public async Task <IActionResult> Create([Bind("Id,Name,Position,MunicipalityId")] Official official)
{
if (ModelState.IsValid)
{
official.Id = Guid.NewGuid();
_context.Add(official);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(official));
}
public SecretWindow(Official official)
{
InitializeComponent();
PayerList.ItemsSource = BillORM.GetBills();
RecipientList.ItemsSource = BillORM.GetBills();
random = new Random();
GenerateNewVariableSymbol();
GenerateNewAmount();
Official = official;
LastTransactions = new List <Transaction>();
GenerateLastTransactions();
}
public OfficialWindow(Official official)
{
InitializeComponent();
activeOfficial = official;
SignedInAsLabel.Content = String.Format("Signed in as: {0} {1}", activeOfficial.Name, activeOfficial.SurName);
log = new Log();
CreateControlsLists();
SetDefaultSettings();
if (activeOfficial.CompanyNumber == "123")
{
MenuItem_SecretPage.Visibility = Visibility.Visible;
}
}
public ActionResult Edit([Bind(Include = "id,fName,mName,lName,userName,passWord,email,phone,mobile,job_id,isLeader,leaderId,entityId,isdeleted")] Official official)
{
if (ModelState.IsValid)
{
db.Entry(official).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.entityId = new SelectList(db.Entities, "id", "Title", official.entityId);
ViewBag.leaderId = new SelectList(db.Officials, "id", "fName", official.leaderId);
ViewBag.job_id = new SelectList(db.OfficialJobs, "id", "Job", official.job_id);
return(View(official));
}
public void Add(OfficialDTO dto)
{
using (var uow = new UnitOfWork(new DataContext()))
{
var obj = new Official();
obj.OfficialGroupID = dto.OfficialGroupID;
obj.OfficialPositionID = dto.OfficialPositionID;
obj.PersonalInfoID = dto.PersonalInfoID;
uow.Officials.Add(obj);
uow.Complete();
dto.ID = obj.OfficialID;
}
}
public async Task <Official> Register(Official official, string password)
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
official.PasswordHash = passwordHash;
official.PasswordSalt = passwordSalt;
await _context.Officials.AddAsync(official);
await _context.SaveChangesAsync();
return(official);
}
// GET: Officials/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Official official = db.Officials.Find(id);
if (official == null)
{
return(HttpNotFound());
}
return(View(official));
}
public void CreateCrew()
{
var boss = new Boss("Bob");
var sterwardessOne = new Stewardess("Jenna");
var sterwardessTwo = new Stewardess("Jessie");
var pilot = new Pilot("James");
var officialOne = new Official("Jhony");
var officialTwo = new Official("Jin");
var cop = new Cop("Dean");
var prisoner = new Prisoner("Sean");
_terminal.AddPassengers(boss, sterwardessOne, sterwardessTwo, pilot, officialOne, officialTwo, cop, prisoner);
}
Official GetAcceptetOfficial()
{
Official ret = null;
if (Detailed.Value && !String.IsNullOrEmpty(AcptFirstName) && !String.IsNullOrEmpty(AcptSurename))
{
ret = new Official();
ret.FirstName = AcptFirstName;
ret.Surname = AcptSurename;
ret.Patronymic = AcptPatronimic;
ret.JobTitle = AcptJobTitle;
return(ret);
}
return(ret);
}
public int CreateOfficial(Official official)
{
string[] attributes =
{ "id:int", "identification:string", "name:string", "last_name:string", "email:string", "password:string", "rol:string", "status:bool" };
string pwd = official.GetAttribute("password")?.ToString();
official.SetPassword(MD5Hash.Hash.Content(pwd));
int id = CreateEntity(official, attributes);
Close();
return(id);
}
/// <summary>
/// Loads The Local Congress Info.
/// </summary>
public async Task <bool> LoadRepresentatives()
{
//Clear All Data
LocalReps.Clear();
StateReps.Clear();
FederalReps.Clear();
//Get Json Data
string RepDataJson = await GetRepData().ConfigureAwait(false);
//Check If It Failed
if (RepDataJson == null)
{
return(false);
}
//Load Up The Reps
List <Representative> TempRepList = new List <Representative>();
Rootobject JsonData = JsonConvert.DeserializeObject <Rootobject>(RepDataJson);
for (int RepIndex = 0; RepIndex < JsonData.officials.Length; RepIndex++)
{
Official CurrentOfficial = JsonData.officials[RepIndex];
TempRepList.Add(new Representative(CurrentOfficial.urls, CurrentOfficial.photoUrl, CurrentOfficial.name, CurrentOfficial.phones, CurrentOfficial.emails, CurrentOfficial.party));
}
//Load Up Gov Positions
for (int officeIndex = 0; officeIndex < JsonData.offices.Length; officeIndex++)
{
for (int i = 0; i < JsonData.offices[officeIndex].officialIndices.Length; i++)
{
int OfficialIndex = JsonData.offices[officeIndex].officialIndices[i];
string[] OfficeLevels = JsonData.offices[officeIndex].levels;
if (OfficeLevels?.Length > 0)
{
TempRepList[OfficialIndex].SetOfficeData(officeIndex, JsonData.offices[officeIndex].name, JsonData.offices[officeIndex].divisionId, OfficeLevels[0]);
}
else
{
TempRepList[OfficialIndex].SetOfficeData(officeIndex, JsonData.offices[officeIndex].name, JsonData.offices[officeIndex].divisionId, "");
}
}
}
//Sort Gov Reps
SortAllReps(TempRepList);
return(true);
}
private Order GetDeepTestGraph()
{
Order root = Order.NewObject();
root.Official = Official.NewObject();
root.OrderTicket = OrderTicket.NewObject();
root.OrderItems.Add(OrderItem.NewObject());
root.OrderItems.Add(OrderItem.NewObject());
root.Customer = Customer.NewObject();
root.Customer.Ceo = Ceo.NewObject();
root.Customer.IndustrialSector = IndustrialSector.NewObject();
root.Customer.IndustrialSector.Companies.Add(Company.NewObject());
root.Customer.IndustrialSector.Companies[1].Ceo = Ceo.NewObject();
root.Customer.IndustrialSector.Companies.Add(Company.NewObject());
root.Customer.IndustrialSector.Companies[2].Ceo = Ceo.NewObject();
return(root);
}
// GET: Officials/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Official official = db.Officials.Find(id);
if (official == null)
{
return(HttpNotFound());
}
ViewBag.entityId = new SelectList(db.Entities, "id", "Title", official.entityId);
ViewBag.leaderId = new SelectList(db.Officials, "id", "fName", official.leaderId);
ViewBag.job_id = new SelectList(db.OfficialJobs, "id", "Job", official.job_id);
return(View(official));
}
public void EndPointsAreCorrectFromBothSidesForCompletelyNewObjectGraphs()
{
Order order;
OrderItem newOrderItem;
OrderTicket newOrderTicket;
Official newOfficial;
Customer newCustomer;
Ceo newCeo;
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
order = Order.NewObject();
newOrderTicket = OrderTicket.NewObject();
order.OrderTicket = newOrderTicket;
newOrderItem = OrderItem.NewObject();
order.OrderItems.Add(newOrderItem);
newOfficial = Official.NewObject();
order.Official = newOfficial;
newCustomer = Customer.NewObject();
order.Customer = newCustomer;
newCeo = Ceo.NewObject();
newCustomer.Ceo = newCeo;
ClientTransactionScope.CurrentTransaction.Commit();
}
Assert.That(newOrderTicket.Order, Is.SameAs(order));
Assert.That(order.OrderTicket, Is.SameAs(newOrderTicket));
Assert.That(order.OrderItems[0], Is.SameAs(newOrderItem));
Assert.That(newOrderItem.Order, Is.SameAs(order));
Assert.That(order.Official.Orders[0], Is.SameAs(order));
Assert.That(order.Official, Is.SameAs(newOfficial));
Assert.That(order.Customer.Orders[0], Is.SameAs(order));
Assert.That(order.Customer, Is.SameAs(newCustomer));
Assert.That(newCustomer.Ceo, Is.SameAs(newCeo));
Assert.That(newCeo.Company, Is.SameAs(newCustomer));
}
public Game(string fileName)
{
using (SpreadsheetDocument document = SpreadsheetDocument.Open(fileName, false))
{
// Retrieve a reference to the workbook part.
WorkbookPart wbPart = document.WorkbookPart;
Sheet theSheet = wbPart.Workbook.Descendants<Sheet>().FirstOrDefault();
// Throw an exception if there is no sheet.
if (theSheet == null)
{
throw new ArgumentException("sheetName Not Found");
}
WorksheetPart wsPart = (WorksheetPart)(wbPart.GetPartById(theSheet.Id));
var excelService = new ExcelService(wbPart, wsPart);
this.GameTitle = excelService.GetValueFromCell("A1");
this.GameVenue = excelService.GetValueFromCell("A2");
this.GameLocation = excelService.GetValueFromCell("A3");
this._defaultTimerMinutes = excelService.GetValueFromCell("A6").GetInt();
this.Announcer1 = excelService.GetValueFromCell("A11");
this.Announcer2 = excelService.GetValueFromCell("A12");
this.Officials = new List<Official>();
var i = 2;
do
{
try
{
if (excelService.GetValueFromCell("B" + i.ToString()) != "XXX")
{
var newOfficial = new Official
{
Name = excelService.GetValueFromCell("C" + i.ToString()),
Title = excelService.GetValueFromCell("B" + i.ToString()),
};
this.Officials.Add(newOfficial);
}
else
{
i = 10;
}
i++;
}
catch (Exception er)
{
throw new ArgumentException("Problem getting officials information");
}
} while (i < 9);
}
gameClock = new Clock(_defaultTimerMinutes);
this.DownInt = 1;
this.YardsToGo = "10";
this.QuarterInt = 1;
}
