public void ModifyOtherObjectInClientTransactionCommitting()
{
_customer.Name = "New name";
TestableClientTransaction.Committing += ClientTransaction_CommittingForModifyOtherObjectInClientTransactionCommitting;
Ceo ceo = _customer.Ceo;
var ceoEventReceiver = new DomainObjectEventReceiver(ceo);
var clientTransactionEventReceiver = new ClientTransactionEventReceiver(TestableClientTransaction);
TestableClientTransaction.Commit();
Assert.That(ceoEventReceiver.HasCommittingEventBeenCalled, Is.True);
Assert.That(ceoEventReceiver.HasCommittedEventBeenCalled, Is.True);
Assert.That(clientTransactionEventReceiver.CommittingDomainObjectLists.Count, Is.EqualTo(2));
Assert.That(clientTransactionEventReceiver.CommittedDomainObjectLists.Count, Is.EqualTo(1));
var committingDomainObjectsForFirstCommitEvent = clientTransactionEventReceiver.CommittingDomainObjectLists[0];
var committingDomainObjectsForSecondCommit = clientTransactionEventReceiver.CommittingDomainObjectLists[1];
var committedDomainObjects = clientTransactionEventReceiver.CommittedDomainObjectLists[0];
Assert.That(committingDomainObjectsForFirstCommitEvent.Count, Is.EqualTo(1));
Assert.That(committingDomainObjectsForSecondCommit.Count, Is.EqualTo(1));
Assert.That(committedDomainObjects.Count, Is.EqualTo(2));
Assert.That(committingDomainObjectsForFirstCommitEvent.Contains(_customer), Is.True);
Assert.That(committingDomainObjectsForFirstCommitEvent.Contains(ceo), Is.False);
Assert.That(committingDomainObjectsForSecondCommit.Contains(_customer), Is.False);
Assert.That(committingDomainObjectsForSecondCommit.Contains(ceo), Is.True);
Assert.That(committedDomainObjects.Contains(_customer), Is.True);
Assert.That(committedDomainObjects.Contains(ceo), Is.True);
}
public static void CalculateBonus()
{
BonusManager bonusManager = new BonusManager();
Employee pedro = new Designer("833.222.048-39");
pedro.Name = "Pedro";
Employee roberta = new Ceo("159.753.398-04");
roberta.Name = "Roberta";
Employee igor = new Auxiliar("981.198.778-53");
igor.Name = "Igor";
Employee camila = new AccountManager("326.985.628-89");
camila.Name = "Camila";
Developer guilherme = new Developer("456.175.468-20");
guilherme.Name = "Guilherme";
bonusManager.Record(guilherme);
bonusManager.Record(pedro);
bonusManager.Record(roberta);
bonusManager.Record(igor);
bonusManager.Record(camila);
Console.WriteLine("Total de bonificações do mês " + bonusManager.GetTotalBonus());
}
public void GetAllRelatedObjects_DoesNotContainIndirectRelatedObjects()
{
Ceo ceo = DomainObjectIDs.Ceo1.GetObject <Ceo> (_transaction);
var relatedObjects = new List <DomainObject> (ceo.Properties.GetAllRelatedObjects());
Assert.That(relatedObjects, Has.No.Member(ceo.Company.IndustrialSector));
}
public static string Chain(int spesa)
{
//Costruisco gli oggetti della catena
var manager = new Manager();
var operational = new OperationalManager();
var ceo = new Ceo();
//Concateno gli anelli
manager.Next(operational).Next(ceo);
//Gli passo le spese per approvarle
var approvata = manager.Handle(spesa);
if (approvata != null)
{
//Se qualcuno la riesce a gestire stampa il risultato
Console.WriteLine(approvata);
return(approvata);
}
else
{
Console.WriteLine($"Nessuno può approvare una spesa di {spesa} euro");
return("RESPINTA");
}
}
public Company(string name, Ceo ceo)
{
this.Name = name;
this.Ceo = ceo;
this.Employees = new List<IEmployee>();
this.Departments = new List<Department>();
}
protected ObjectID CreateCompanyAndSetIndustrialSectorInOtherTransaction(ObjectID industrialSectorID)
{
return(RelationInconcsistenciesTestHelper.CreateObjectAndSetRelationInOtherTransaction <Company, IndustrialSector> (industrialSectorID, (c, s) =>
{
c.IndustrialSector = s;
c.Ceo = Ceo.NewObject();
}));
}
static void Main(string[] args)
{
FileSystemWatcher fsw = new FileSystemWatcher();
//specifico la directory da tenere sotto controllo
fsw.Path = @"C:\Users\simona.loperfido\Desktop\7 MAGGIO\ProvaPratica";
//filtro che caratterizza i file da tenere sotto controllo
fsw.Filter = "*.txt";
//richiedo la notifica di un insieme di eventi
fsw.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastAccess;
//abilitiamo le notifiche
fsw.EnableRaisingEvents = true;
//multicast delegate -> alla creazione del file viene gestito l'evento
fsw.Created += GestioneSpesa.HandleNewTextFile;
IFileSerializable spesa = new GestioneSpesa();
spesa.LoadFromFile("spesa.txt");
spesa.SaveToFile("spesa.txt");
//Dovrei fare queste operazioni per ogni riga che vado a leggere
//Chain of Responsibility pattern
var manager = new Manager();
var operationalManager = new OperationalManager();
var ceo = new Ceo();
var noApp = new NoApprovazione();
//catena di responsabilità:
manager.SetNext(operationalManager).SetNext(ceo).SetNext(noApp);
//List<double> importo = new List<double> { 400, 560, 2000, 150, 60, 2700 };
//foreach (var imp in importo)
//{
// Console.WriteLine($"Hai speso {imp} euro - Sarà approvata la tua spesa?");
// var result = manager.Handle(imp); //invio richiesta
// //gestione risultato
// if (result != null)
// {
// Console.WriteLine(result);
// }
// else
// {
// Console.WriteLine("Nessuna spesa viene approvata sopra i " + imp);
// }
//}
//Factory pattern
//ICategoria categoria = CategoriaFactory.FactoryCategoria(param);
//Console.WriteLine(categoria.TipoCategoria());
}
public void GetOriginalRelatedObject()
{
Partner partner = Partner.NewObject();
Ceo ceo = Ceo.NewObject();
partner.Ceo = ceo;
Assert.That(partner.GetOriginalRelatedObject("Remotion.Data.DomainObjects.UnitTests.TestDomain.Company.Ceo"), Is.Null);
Assert.That(ceo.GetOriginalRelatedObject("Remotion.Data.DomainObjects.UnitTests.TestDomain.Ceo.Company"), Is.Null);
}
public void StateForOneToOneRelationChange()
{
Partner partner = Partner.NewObject();
Ceo ceo = Ceo.NewObject();
partner.Ceo = ceo;
Assert.That(partner.State, Is.EqualTo(StateType.New));
Assert.That(ceo.State, Is.EqualTo(StateType.New));
}
public void GetRelatedObjectByInheritedRelationTwice()
{
Customer customer = DomainObjectIDs.Customer4.GetObject <Customer> ();
Ceo ceoReference1 = customer.Ceo;
Ceo ceoReference2 = customer.Ceo;
Assert.That(ceoReference2, Is.SameAs(ceoReference1));
}
public override string Execute()
{
IOrganizationalUnit company = this.db.Companies.FirstOrDefault(c => c.Name == companyName);
if (company == null)
{
throw new ArgumentException(String.Format("Company {0} does not exist", companyName));
}
ceo = (Ceo)company.Head;
Pay(company, 0, 0);
return output.ToString();
}
private static void Main(string[] args)
{
Console.WriteLine("Template Method Mode Demo");
var manager = new Manager();
manager.GetSalary();
var ceo = new Ceo();
ceo.GetSalary();
}
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 void GetDerivedRelatedObject()
{
Ceo ceo = DomainObjectIDs.Ceo10.GetObject <Ceo> ();
Company company = ceo.Company;
Assert.That(company, Is.Not.Null);
var distributor = company as Distributor;
Assert.That(distributor, Is.Not.Null);
}
public void Constructor_CreateMultipleCeos_ValidateTheyShareSameName()
{
var ceo = new Ceo()
{
Name = "Jane Doe",
Age = 25
};
var ceo2 = new Ceo();
Assert.That(ceo2.Name, Is.EqualTo("Jane Doe"));
}
public void ModifyOtherObjects()
{
_customer.Name = "New name";
Ceo ceo = _customer.Ceo;
ceo.Name = "New CEO name";
Order order = _customer.Orders[DomainObjectIDs.Order1];
IndustrialSector industrialSector = _customer.IndustrialSector;
var ceoEventReceiver = new DomainObjectEventReceiver(ceo);
var customerEventReceiver = new DomainObjectEventReceiver(_customer);
var orderEventReceiver = new DomainObjectEventReceiver(order);
var industrialSectorEventReceiver = new DomainObjectEventReceiver(industrialSector);
var clientTransactionEventReceiver = new ClientTransactionEventReceiver(TestableClientTransaction);
_customer.Committing += (sender, e) => order.OrderNumber = 1000;
TestableClientTransaction.Committing += (sender1, args) =>
{
var customer = (Customer)args.DomainObjects.SingleOrDefault(obj => obj.ID == DomainObjectIDs.Customer1);
if (customer != null)
{
customer.IndustrialSector.Name = "New industrial sector name";
}
};
TestableClientTransaction.Commit();
Assert.That(ceoEventReceiver.HasCommittingEventBeenCalled, Is.True);
Assert.That(ceoEventReceiver.HasCommittedEventBeenCalled, Is.True);
Assert.That(customerEventReceiver.HasCommittingEventBeenCalled, Is.True);
Assert.That(customerEventReceiver.HasCommittedEventBeenCalled, Is.True);
Assert.That(orderEventReceiver.HasCommittingEventBeenCalled, Is.True);
Assert.That(orderEventReceiver.HasCommittedEventBeenCalled, Is.True);
Assert.That(industrialSectorEventReceiver.HasCommittingEventBeenCalled, Is.True);
Assert.That(industrialSectorEventReceiver.HasCommittedEventBeenCalled, Is.True);
Assert.That(clientTransactionEventReceiver.CommittingDomainObjectLists.Count, Is.EqualTo(2));
Assert.That(clientTransactionEventReceiver.CommittedDomainObjectLists.Count, Is.EqualTo(1));
var committingDomainObjectsForFirstCommitEvent = clientTransactionEventReceiver.CommittingDomainObjectLists[0];
var committingDomainObjectsForSecondCommitEvent = clientTransactionEventReceiver.CommittingDomainObjectLists[1];
var committedDomainObjects = clientTransactionEventReceiver.CommittedDomainObjectLists[0];
Assert.That(committingDomainObjectsForFirstCommitEvent, Is.EquivalentTo(new DomainObject[] { _customer, ceo }));
Assert.That(committingDomainObjectsForSecondCommitEvent, Is.EquivalentTo(new DomainObject[] { order, industrialSector }));
Assert.That(committedDomainObjects, Is.EquivalentTo(new DomainObject[] { _customer, ceo, order, industrialSector }));
}
protected Company CreateCompanyInDatabaseAndLoad()
{
ObjectID objectID;
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
var company = Company.NewObject();
company.Ceo = Ceo.NewObject();
ClientTransaction.Current.Commit();
objectID = company.ID;
}
return(objectID.GetObject <Company> ());
}
public void SetRelatedObject()
{
Partner partner = Partner.NewObject();
Ceo ceo = Ceo.NewObject();
Assert.That(partner.Ceo, Is.Null);
Assert.That(ceo.Company, Is.Null);
partner.Ceo = ceo;
Assert.That(ceo.Company, Is.SameAs(partner));
Assert.That(partner.Ceo, Is.SameAs(ceo));
}
private static void MonoState()
{
var ceo = new Ceo
{
Name = "Jeff",
Age = 12
};
Console.WriteLine(ceo);
var newCeo = new Ceo();
Console.WriteLine(newCeo);
}
public ActionResult CeoAyar(Ceo yeniceo)
{
var ceo = db.Ceos.Where(w => w.CeoID == 1).SingleOrDefault();
ceo.SiteBaslik = yeniceo.SiteBaslik;
ceo.SiteAciklama = yeniceo.SiteAciklama;
ceo.SiteSahip = yeniceo.SiteSahip;
ceo.SiteYonetici = yeniceo.SiteYonetici;
ceo.SiteKurulus = yeniceo.SiteKurulus;
ceo.SiteKeys = yeniceo.SiteKeys;
ceo.GoogleAnalytics = yeniceo.GoogleAnalytics;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void SetRelatedObjectWithInvalidObjectClassOnVirtualRelationEndPoint()
{
var newRelatedObject = Ceo.NewObject();
var expectedMessage = string.Format(
"DomainObject '{0}' cannot be assigned to property '{1}' of DomainObject '{2}',"
+ " because it is not compatible with the type of the property.\r\nParameter name: newRelatedObject",
newRelatedObject,
"Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.OrderTicket",
_order);
Assert.That(
() => _order.SetRelatedObject("Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.OrderTicket", newRelatedObject),
Throws.ArgumentException.And.Message.EqualTo(expectedMessage));
}
public void CalculateSalaries(dynamic[] employees)
{
foreach (var employee in employees)
{
if (employee is Ceo)
{
Ceo ceo = (Ceo)employee;
ceo.CalculateSalary();
}
else if (employee is Programmer)
{
Programmer programmer = (Programmer)employee;
programmer.CalculateSalary();
}
}
}
public void ShowIdCards(dynamic[] employees)
{
foreach (var employee in employees)
{
if (employee is Ceo)
{
Ceo ceo = (Ceo)employee;
ceo.ShowIdCard();
}
else if (employee is Programmer)
{
Programmer programmer = (Programmer)employee;
programmer.ShowIdCard();
}
}
}
protected IndustrialSector CreateIndustrialSectorInDatabaseAndLoad()
{
ObjectID objectID;
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
IndustrialSector industrialSector = IndustrialSector.NewObject();
Company oldCompany = Company.NewObject();
oldCompany.Ceo = Ceo.NewObject();
industrialSector.Companies.Add(oldCompany);
objectID = industrialSector.ID;
ClientTransaction.Current.Commit();
}
return(objectID.GetObject <IndustrialSector> ());
}
static void Main(string[] args)
{
Manager Bob = new Manager("Bob", "Bobsky", 2542);
Manager John = new Manager("John", "Jonissimo", 5000);
Contractor Mona = new Contractor("Mona", "Monalisa", 80, 120, Bob);
Contractor Igor = new Contractor("Igor", "Igorski", 85, 100, John);
SalesPerson Lea = new SalesPerson("Lea", "Leova", 87);
Employee[] company = { Bob, John, Mona, Igor, Lea };
Ceo Ron = new Ceo("Ron", "Ronsky", company, 1500);
Ron.AddSharesPrice(103);
Console.WriteLine("Info " + Ron.GetInfo());
Console.WriteLine("Salary " + Ron.GetSalary());
Ron.GetEmployees();
}
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);
}
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));
}
static void Main(string[] args)
{
Manager john = new Manager("John", "Doe");
john.AddBonus(1000);
john.GetSalary();
Manager boki = new Manager("Boki", "Bobov");
boki.AddBonus(1200);
boki.GetSalary();
Contractor koki = new Contractor("Koki", "Kokov", john, 40);
koki.GetSalary();
Contractor viki = new Contractor("Viki", "Vikova", boki, 50);
viki.GetSalary();
SalesPerson martin = new SalesPerson("Martin", "Martinov");
martin.ExtendSuccessRevenue(3000);
martin.GetSalary();
Employee[] companyEmployees =
{
john,
boki,
koki,
viki,
martin
};
Ceo trump = new Ceo("Donald", "Trump", 7000, companyEmployees);
trump.AddSharesPrice(100);
trump.GetSalary();
trump.PrintInfo();
trump.PrintEmployees();
Console.ReadLine();
}
static void Main(string[] args)
{
///---Task 01---
Employee employee = new Employee("Bob", "Bobsky", Role.Other, 600);
SalesPerson salesPerson = new SalesPerson("Bill", "Billsky", 1500);
Manager manager = new Manager("Elon", "Musk", 5000);
Contractor contractor1 = new Contractor("Jeff", "Besos", 170, 11, manager);
Contractor contractor2 = new Contractor("Mark", "Raffalo", 155, 9, manager);
salesPerson.ExtendSuccessRevenue(2000);
manager.AddBonus(4000);
salesPerson.ExtendSuccessRevenue(3000);
Console.WriteLine(employee.GetInfo());
Console.WriteLine(salesPerson.GetInfo());
Console.WriteLine(manager.GetInfo());
Console.WriteLine($"{ contractor1.FirstName} - { contractor1.CurrentPosition("marketing")}");
Console.WriteLine($"{ contractor2.FirstName} - { contractor2.CurrentPosition("IT")}");
Console.WriteLine($"Employee salary: {employee.GetSalary()}");
Console.WriteLine($"SalesPerson salary: {salesPerson.GetSalary()}");
Console.WriteLine($"Manager salary: {manager.GetSalary()}");
Console.WriteLine($"First Constructor is {contractor1.FirstName} and his/her salary is: {contractor1.GetSalary()}");
Console.WriteLine($"Second Constructor is {contractor2.FirstName} and his/her salary is: {contractor2.GetSalary()}");
///--Task 02---
Ceo ceo = new Ceo("Steve", "Jobs", 70, 340);
Console.WriteLine($"{ceo.GetInfo()}");
Console.Write($"The ceo has salary of: {ceo.GetSalary()} dolars.");
}
public static void UsingSystem()
{
InternalSystem internalSystem = new InternalSystem();
Ceo roberta = new Ceo("13123213");
roberta.Name = "Roberta";
roberta.Password = "******";
SalesPartner camila = new SalesPartner();
camila.Password = "******";
Console.WriteLine("roberta");
internalSystem.SignIn(roberta, "123");
internalSystem.SignIn(roberta, "345");
Console.WriteLine("camila");
internalSystem.SignIn(camila, "123");
internalSystem.SignIn(camila, "345");
}
public void OldObjectAndNewObjectAreSameRelationInherited()
{
Customer customer = DomainObjectIDs.Customer4.GetObject <Customer> ();
Ceo ceo = customer.Ceo;
SequenceEventReceiver eventReceiver = new SequenceEventReceiver(
new DomainObject[] { customer, ceo },
new DomainObjectCollection[0]);
Assert.That(customer.State, Is.EqualTo(StateType.Unchanged));
Assert.That(ceo.State, Is.EqualTo(StateType.Unchanged));
customer.Ceo = ceo;
Assert.That(customer.State, Is.EqualTo(StateType.Unchanged));
Assert.That(ceo.State, Is.EqualTo(StateType.Unchanged));
ChangeState[] expectedStates = new ChangeState[0];
eventReceiver.Check(expectedStates);
}
public void CommitPolymorphicRelation()
{
Ceo companyCeo = DomainObjectIDs.Ceo1.GetObject <Ceo> ();
Ceo distributorCeo = DomainObjectIDs.Ceo10.GetObject <Ceo> ();
Company company = companyCeo.Company;
Distributor distributor = DomainObjectIDs.Distributor1.GetObject <Distributor> ();
distributor.Ceo = companyCeo;
company.Ceo = distributorCeo;
TestableClientTransaction.Commit();
ReInitializeTransaction();
companyCeo = DomainObjectIDs.Ceo1.GetObject <Ceo> ();
distributorCeo = DomainObjectIDs.Ceo10.GetObject <Ceo> ();
company = DomainObjectIDs.Company1.GetObject <Company> ();
distributor = DomainObjectIDs.Distributor1.GetObject <Distributor> ();
Assert.That(distributor.Ceo, Is.SameAs(companyCeo));
Assert.That(companyCeo.Company, Is.SameAs(distributor));
Assert.That(company.Ceo, Is.SameAs(distributorCeo));
Assert.That(distributorCeo.Company, Is.SameAs(company));
}
private string ExecuteCreateCompanyCommand(ICommand command)
{
var ceo = new Ceo(command.Parameters[1], command.Parameters[2], decimal.Parse(command.Parameters[3]));
database.TotalSalaries[ceo] = 0m;
var company = new Company(command.Parameters[0], ceo);
if (database.Companies.Any(c => c.Name == company.Name))
{
return string.Format("Company {0} already exists", company.Name);
}
this.database.Companies.Add(company);
return null;
}
