public IActionResult CarView(string licensePlate)
{
bool carExistsInDb = new CarDb(_config).carExists(licensePlate);
if (carExistsInDb)
{
var model = new CarViewModel();
var newCar = new CarDb(_config).getCar(licensePlate);
var companyNameFromDB = new SettingsDb(_config).GetCompanyName(newCar.CompanyId);
model.car = newCar;
model.companyName = companyNameFromDB;
return(View(model));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
/// <summary>
/// Removes all items from all DbSets
/// </summary>
public void ClearCollection()
{
foreach (Car it in CarDb)
{
CarDb.Remove(it);
}
foreach (var it in NotebookDb)
{
NotebookDb.Remove(it);
}
foreach (var it in RepairDb)
{
RepairDb.Remove(it);
}
foreach (var it in FuelDb)
{
FuelDb.Remove(it);
}
this.SaveChanges();
}
protected void Page_Load(object sender, EventArgs e)
{
if (!this.IsPostBack)
{
var cars = CarDb.GetProducers();
this.CarProducer.DataSource = cars;
this.CarProducer.DataBind();
Producer producer = cars.FirstOrDefault(x => x.Name == this.CarProducer.Text);
List <string> models = producer.Models;
this.CarModel.DataSource = models;
this.CarModel.DataBind();
var extras = CarDb.GetExtras();
this.CarExtras.DataSource = extras;
this.CarExtras.DataBind();
var engines = CarDb.GetEngineType();
this.CarEngine.DataSource = engines;
this.CarEngine.DataBind();
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
//Create Cars database...
Database.SetInitializer(new DropCreateDatabaseIfModelChanges <CarDb>());
InsertData();
//Create access to Cars database...
var db = new CarDb();
//db.Database.Log = Console.WriteLine;
//Populate Make drop-down...
//Populate Model drop-down...
//Populate Automobiles Grid View...
var query =
from car in db.Cars
group car by car.Manufacturer into manufacturer
select new
{
Name = manufacturer.Key,
Cars = (from car in manufacturer
orderby car.Combined descending
select car).Take(2)
};
gvAutomobiles.DataSource = query.ToList();
gvAutomobiles.DataBind();
}
}
public HttpResponseMessage GetRoles()
{
var list = CarDb.GetRoles();
return(CarDb.CreateJsonResponse(list));
}
public Account GetUserClaims()
{
return(CarDb.GetUserClaims());
}
public Account ActivateUser()
{
return(CarDb.ActivateUser());
}
public IdentityResult Signup(Account account)
{
return(CarDb.Signup(account));
}
public HttpResponseMessage ResetOptions()
{
var result = CarDb.ResetOptions();
return(CarDb.CreateJsonResponse(result));
}
static void Main(string[] args)
{
Console.WriteLine("---------------------------------");
#region S
Console.WriteLine("S - Responsabilidad Simple");
Console.WriteLine("Incorrecto");
// Una sola clase tiene la responsabilidad del objeto
// y la de almacenarlo en la base de datos eso esta en
// desacuerdo con el principio
var carBad = new sb.Car("Renault");
carBad.saveCarDB(carBad);
Console.WriteLine("Correcto");
// Lo correcto es que cada responsabilidad sea separada
// en clases diferentes
var car = new Car("Renault");
var cadDB = new CarDb();
cadDB.saveCarDB(car);
#endregion
Console.WriteLine("---------------------------------");
Console.WriteLine("0 - Abierto Cerrado");
#region O
Console.WriteLine("Incorrecto");
// Si agregamos un item en el arreglo carsBadArray se debe
// modificar el método viewCostCarBad, lo cual no cumple
// el principio Abierto/Cerrado
// Para cada nuevo carro se debería modificar la funcionalidad
sb.Car[] carsBadArray =
{
new sb.Car("Renault"),
new sb.Car("Audi")//,
//new sb.Car("Susuzi")
};
viewCostCarBad(carsBadArray);
Console.WriteLine("Correcto");
// Si agregamos un nuevo item al arreglo carsArray no será
// necesario hacer modificaciones en el médodo viewCostCar
AbstractCar[] carsArray =
{
new RenaultModel(),
new AudiModel()//,
//new SusukiModel()
};
viewCostCar(carsArray);
#endregion
Console.WriteLine("---------------------------------");
Console.WriteLine("L - Suplantación de Liskov");
// Llamamos al método Sustitution, para evaluar el comportamiento
Sustitution(carsArray);
Console.WriteLine("---------------------------------");
#region I
Console.WriteLine("I - Segregación de interfaces");
Console.WriteLine("Incorrecto");
// Cuando la interfaz tiene metodos que la clase no debe implementar
// estos generan comportamientos innecesarios que no deberian tener
ChickenBad chickenBad = new ChickenBad();
chickenBad.Eat();
try{
chickenBad.Fly();
} catch (Exception ex) {
Console.WriteLine(ex.Message);
}
Console.WriteLine("Correcto");
// Cuando se dividen las interfaces las implementaciones no tienen
// funcionalidades que no necesitan
Chicken chicken = new Chicken();
chicken.Eat();
//chicken.Fly(); No es implementado en la clase Chicken
#endregion
Console.WriteLine("---------------------------------");
#region D
Console.WriteLine("D - Inversión de dependencias");
// Cuando los sistemas son bastante grandes se utiliza
// inyección de dependencias para cargar modulos
Console.WriteLine("Incorrecto");
// Si por alguna razón cambio el servicio de acceso a datos
// debo modificar todas las instancias del accesso
DataBadService dataBadService = new DataBadService();
DataBadAccess dataBadAccess = new DataBadAccess(dataBadService);
dataBadAccess.GetData("Carros");
Console.WriteLine("Correcto");
// Cuando se hace usando las interfaces no es necesario cambiar todas
// las instancias, ya que utilizamos la abstracción no la concreción
// Puede intercambiar ApiService con DataBaseService
ApiService service = new ApiService();
//DataBaseService service = new DataBaseService();
DataAccess dataAccess = new DataAccess(service);
dataAccess.GetData("Carros");
#endregion
}
