void Update()
{
if (!GameObject.Find("Car").GetComponent <CombineMeshes> ().isActiveAndEnabled)
{
createCar = GameObject.FindObjectOfType <CreateCar> ();
if (createCar.model == CreateCar.Model.Basic)
{
basicBottom = GameObject.Find("Underside").GetComponent <Underside> ();
width = Vector3.Lerp(basicBottom.mesh.vertices [0], basicBottom.mesh.vertices [1], 0.5f);
length = Vector3.Lerp(basicBottom.mesh.vertices [1], basicBottom.mesh.vertices [3], 0.5f);
}
else if (createCar.model == CreateCar.Model.Classic)
{
classicBottom = GameObject.Find("Classic9Bottom").GetComponent <Classic9Bottom> ();
width = Vector3.Lerp(classicBottom.mesh.vertices [0], classicBottom.mesh.vertices [1], 0.5f);
length = Vector3.Lerp(classicBottom.mesh.vertices [1], classicBottom.mesh.vertices [3], 0.5f);
}
else if (createCar.model == CreateCar.Model.Van)
{
vanBottom = GameObject.Find("Van13Underside").GetComponent <Van13Underside> ();
width = Vector3.Lerp(vanBottom.mesh.vertices [0], vanBottom.mesh.vertices [1], 0.5f);
length = Vector3.Lerp(vanBottom.mesh.vertices [1], vanBottom.mesh.vertices [3], 0.5f);
}
centerPoint = new Vector3(width.x, 0, length.z);
gameObject.transform.RotateAround(centerPoint, Vector3.up, angle * Time.deltaTime);
}
}
public async Task<IActionResult> Post([FromBody] CreateCar command)
{
command.CarId = Guid.NewGuid();
await _carService.CreateAsync(command.CarId, command.Mark, command.Model, command.Capacity, command.DateOc, command.DateReview, command.CarType);
return Created($"/cars/{command.CarId}", null);
}
public CarAgr(CreateCar command) : base(command.Id)
{
ApplyChange(
new CarCreated(
command.Model,
command.HorsePower,
this,
command));
}
public CreateCar CarToCreateCar(Car car)
{
CreateCar createCar = new CreateCar(_carBrandRepo);
createCar.Brand = car.Brand;
createCar.ModelName = car.ModelName;
createCar.Price = car.Price;
return(createCar);
}
public async Task <IActionResult> Create([FromBody] CreateCar request)
{
var carId = await _manageCarService.Create(request);
//if (carId == 0)
// return BadRequest();
var car = await _manageCarService.GetById(carId);
return(CreatedAtAction(nameof(GetById), new { id = carId }, car));
}
public ActionResult <Car> Create([FromBody] CreateCar car)
{
//ModelState.isValid
if (ModelState.IsValid)
{
return(_carService.Add(car));
}
return(BadRequest(car));
}
public IActionResult Create(CreateCar createCar)
{
if (ModelState.IsValid)
{
_carService.Add(createCar);
return(RedirectToAction(nameof(Index)));
}
return(View(createCar));
}
public Car Add(CreateCar createCar)
{
Car car = new Car();
car.Brand = createCar.Brand;
car.ModelName = createCar.ModelName;
car.Price = createCar.Price;
car = _carRepo.Create(car);
return(car);
}
public void WhenICreateANewCarForCustomerWithTheFollowingDetails(string customerName, Table table)
{
var values = table.Rows.Single();
_uiViewInfo = new CarUiViewInfo(
values["Registration"],
values["Make"],
values["Model"],
values["Year"]);
_actor.AttemptsTo(
CreateCar.WithRegistration(_uiViewInfo.Registration)
.AndMake(_uiViewInfo.Make)
.AndModel(_uiViewInfo.Model)
.ForYear(_uiViewInfo.Year));
}
public IActionResult Edit(int id, CreateCar createCar)
{
if (ModelState.IsValid)
{
Car car = _carService.Edit(id, createCar);
return(RedirectToAction(nameof(Index)));
}
EditCar editCar = new EditCar();
editCar.Id = id;
editCar.CreateCar = createCar;
return(View(editCar));
}
public async Task AddCar([FromBody] CarRead carRead)
{
var createCar = new CreateCar
{
CompanyId = carRead.CompanyId,
CreationTime = carRead.CreationTime,
CarId = carRead.CarId,
RegNr = carRead.RegNr,
VIN = carRead.VIN,
Locked = carRead.Locked,
Online = carRead.Online,
Speed = carRead.Speed,
CreateCarTimeStamp = DateTime.Now.Ticks
};
var createOnlineStatus = new CreateCarOnlineStatus
{
CarId = carRead.CarId,
CompanyId = carRead.CompanyId,
OnlineStatus = carRead.Online,
CreateCarOnlineTimeStamp = DateTime.Now.Ticks
};
var createLockedStatus = new CreateCarLockedStatus
{
CarId = carRead.CarId,
CompanyId = carRead.CompanyId,
LockedStatus = carRead.Locked,
CreateCarLockedTimeStamp = DateTime.Now.Ticks
};
var createSpeed = new CreateCarSpeed
{
CarId = carRead.CarId,
CompanyId = carRead.CompanyId,
Speed = carRead.Speed,
CreateCarSpeedTimeStamp = DateTime.Now.Ticks
};
await _endpointInstance.Send(Helpers.ServerEndpoint, createCar).ConfigureAwait(false);
await _endpointInstance.Send(Helpers.ServerEndpoint, createOnlineStatus).ConfigureAwait(false);
await _endpointInstance.Send(Helpers.ServerEndpoint, createLockedStatus).ConfigureAwait(false);
await _endpointInstance.Send(Helpers.ServerEndpoint, createSpeed).ConfigureAwait(false);
}
public Car Edit(int id, CreateCar car)
{
Car originalCar = FindById(id);
if (originalCar == null)
{
return(null);
}
originalCar.Brand = car.Brand;
originalCar.ModelName = car.ModelName;
originalCar.Price = car.Price;
originalCar = _carRepo.Update(originalCar);
return(originalCar);
}
static void CreateTechnicalService()
{
Car c = new Car("s", 0, "a", 1, true, 1);
CreateProject cp = new CreateProject();
cp.CreateNewProject(1, "P1", 1);
CreateCar cc = new CreateCar();
cc.CreateNewCar("s", 0, "a", 1, true, 1);
cc.CreateNewComponent(123, "Двигатель");
cc.CreateNewComponent(124, "КПП");
Console.WriteLine(cc.ShowComponents());
cc.setComponentInCar(1, 123);
cc.setComponentInCar(1, 124);
Console.WriteLine(cc.Cars[0].ToString());
cc.Cars[0].ShowComponents();
}
public async Task Add_Comand_Event_Handler_Async()
{
var command = new CreateCar(Guid.NewGuid(), "mercedes", 2,
new CommandMeta()
{
CorrelationId = Guid.NewGuid(), UserId = "geno"
});
var carAgr = new CarAgr(command);
await _eventStore.AppendAsync(carAgr.GetUncommittedEvents());
var RestoreAgr = await _eventStore.RestoreAsync(carAgr.Id);
Assert.Equal(carAgr.Id, RestoreAgr.Id);
}
public async Task <IHttpActionResult> AddCar(CreateCar car)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var carToAdd = new Common.Models.Car
{
Color = (Common.Models.CarColor)car.Color,
PlateNumber = car.PlateNumber
};
var createdCar = await _repository.CreateCar(carToAdd);
var result = new Car
{
Id = createdCar.Id,
PlateNumber = createdCar.PlateNumber,
Color = (CarColor)createdCar.Color
};
return(Created <Car>(new Uri(Request.RequestUri.ToString() + createdCar.Id), result));
}
public Task CreateCar([FromBody] CreateCar command)
{
return(_mediator.Send(command));
}
public void Add([FromBody] CreateCar createCar)
{
_carApplication.Create(createCar);
}
public async Task <CommandResult> Do(CreateCar command)
{
await Emit(new CarCreated(command.Id, command.Name));
return(CommandResult.Success);
}
public async Task <IActionResult> Post([FromBody] CreateCar command)
{
await _busClient.PublishAsync(command);
return(Accepted($"cars/{command.Id}"));
}
public void HandleThread()
{
bool end = false;
binaryFormatter = new BinaryFormatter();
while (!end)
{
try
{
DataTransferObject transferClass =
(DataTransferObject)binaryFormatter.Deserialize(clientStream);
switch (transferClass.Operation)
{
case Operation.SignIn:
SignInUser signInUser
= new SignInUser();
transferClass.Result = signInUser.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.SignUp:
RegisterUser registerUser = new RegisterUser();
transferClass.Result = registerUser.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.LogOut:
end = true;
break;
case Operation.CreateCar:
CreateCar createCar = new CreateCar();
transferClass.Result = createCar.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.GetAllCars:
GetAllCars get = new GetAllCars();
transferClass.Result = get.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.GetAllReservations:
GetReservations reservations = new GetReservations();
transferClass.Result = reservations.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.CreateReservation:
CreateReservation createReservation = new CreateReservation();
transferClass.Result = createReservation.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.DeleteCar:
DeleteUser deleteUser = new DeleteUser();
transferClass.Result = deleteUser.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.DeleteReservation:
DeleteReservation deleteReservation = new DeleteReservation();
transferClass.Result = deleteReservation.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.FindCar:
FindCars findCar = new FindCars();
transferClass.Result = findCar.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.FindReservation:
GetReservations findReservation = new GetReservations();
transferClass.Result = findReservation.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.FindByIDCar:
FindByIdCar find = new FindByIdCar();
transferClass.Result = find.ExecuteSystemOperation(transferClass.Object);
break;
case Operation.FindByIDReservation:
FindByIdReservation findByIdReservation = new FindByIdReservation();
transferClass.Result = findByIdReservation.ExecuteSystemOperation(transferClass.Object);
break;
}
binaryFormatter.Serialize(clientStream, transferClass);
}
catch (Exception)
{
end = true;
}
}
}
public void Create(CreateCar command)
{
var newCar = new Car(command.Model, command.CarTypeId, _carValidationService);
_carRepository.Create(newCar);
}
