private void buttonSearch_Click(object sender, EventArgs e)
{
Console.WriteLine("search button click");
TypeBookNo bno = new TypeBookNo(int.Parse(textBoxBookNo.Text));
TypeBookName bname = new TypeBookName(textBoxBookName.Text);
//TypeRentalState rental = new TypeRentalState(TypeRentalState.RentalState.NoRental);
//パラメータ設定
ParamList param = new ParamBooksSearch();
param.SetParam(bno);
param.SetParam(bname);
//param.SetParam(rental);
//検索実行
ServiceInterface srv = new ServiceBooksSearch(param);
srv.Run();
//検索結果の取り出し
TypeBookAggregate books = (TypeBookAggregate)param.GetParam(DataType.BookAggregate);
AggregateBase agb = books.BookAggregate();
IteratorBase ite = agb.Iterator();
if (ite.HasNext())
{
DataListBookInfo info = (DataListBookInfo)ite.Next();
// Console.WriteLine(info.BookName());
}
}
public void AggregateBaseConstructor_BorderParameters(double costPerKw, double power, bool state)
{
AggregateBase aggregate = new AggregateBase(costPerKw, power, state);
Assert.AreEqual(aggregate.CostPerHour, costPerKw);
Assert.AreEqual(aggregate.Power, power);
Assert.AreEqual(aggregate.State, state);
}
public async Task Repo_Can_Not_Create_An_Empty_Agregate_Using_GetByIdAsync()
{
// Arrange, Act
AggregateBase <int, int> aggregate = _repo.GetById(10);
aggregate = await _repo.GetByIdAsync(10).ConfigureAwait(false);
// Assert
aggregate.Should().BeNull();
}
public void Store(AggregateBase aggregate)
{
using (var session = _store.OpenSession())
{
// Take non-persisted events, push them to the event stream, indexed by the aggregate ID
var events = aggregate.GetUncommittedEvents().ToArray();
session.Events.Append(aggregate.Id, aggregate.Version, events);
session.SaveChanges();
}
// Once succesfully persisted, clear events from list of uncommitted events
aggregate.ClearUncommittedEvents();
}
public void load_item_from_eventStream()
{
var stream = new EventStream
{
Events =
new List <object>(new[]
{
new AnagraficaArticoloCensita(TestConfig.Id, "001", "SSD Crucial M4 256GB", "NR", 100)
}),
Version = 1
};
var item = AggregateBase.Load <AnagraficaArticolo>(stream);
Assert.AreEqual(1, item.Version);
Assert.AreEqual(TestConfig.Id, item.Id);
}
private WindGenerator GetWindGeneratorFromDataBase(string city)
{
#region Generate base objects
WeatherBase weatherBase = null;
WindGeneratorBase windGeneratorBase = Task<WindGeneratorBase>.Factory.StartNew(()=> Repositories.windGeneratorRepository.GetOneWindGenerator(city)).Result;
WindMillBase windMillBase = Task<WindMillBase>.Factory.StartNew(() => Repositories.windMillRepository.GetOneWindMill(windGeneratorBase.WindMill)).Result;
AggregateBase aggregateBase = Task<AggregateBase>.Factory.StartNew(() => Repositories.aggregateRepository.GetOneAggregate(windGeneratorBase.Aggregate)).Result;
weatherBase = Task<WeatherBase>.Factory.StartNew(() => Repositories.weatherRepository.GetLastWeather(windGeneratorBase.Weather)).Result;
#endregion
#region Logics for aggregate state and cost
if ((windGeneratorBase.Power = windGeneratorBase.CalculatePower()) < windMillBase.MinPower)
{
windGeneratorBase.AggregateONCnt++;
aggregateBase.State = true;
}
else
{
aggregateBase.State = false;
}
windGeneratorBase.TotalAggregateCost = windGeneratorBase.CalculateTotalAggregateCost(120);
#endregion
#region Write in database
Repositories.windGeneratorRepository.AddOrReplaceWindGenerator(windGeneratorBase);
Repositories.aggregateRepository.AddOrReplaceAggregate(aggregateBase);
#endregion
#region Generate wcf objects
Aggregate aggregate = new Aggregate(int.Parse(aggregateBase.RowKey), aggregateBase.CostPerHour, aggregateBase.Power, aggregateBase.State);
WindMill windMill = new WindMill(windMillBase.Coefficient, windMillBase.MinPower, windMillBase.TurbineDiameter, windMillBase.MaxSpeed, windMillBase.MaxSpeedTime,windMillBase.WorkingTime);
if (weatherBase == null)
weatherBase = Task<WeatherBase>.Factory.StartNew(() => Repositories.weatherRepository.GetOneWeather(windGeneratorBase.Weather)).Result;
Weather weather = new Weather(weatherBase.City, weatherBase.Description, weatherBase.MaxTemp, weatherBase.MinTemp, weatherBase.Pressure, weatherBase.WindSpeed);
return new WindGenerator(weather, windMill, windGeneratorBase.WindMillCnt, aggregate,windGeneratorBase.AggregateONCnt,windGeneratorBase.Power);
#endregion
}
public Task Save(AggregateBase aggregate, int expectedVersion)
{
_store.Put(aggregate.Id, aggregate.GetUncommittedChanges(), expectedVersion);
return(Task.FromResult(0));
}
public static bool HasValidId(this AggregateBase aggregate)
{
return(aggregate.Id != Guid.Empty);
}
public ConcreteIterator(AggregateBase aggregate)
{
aggregate_ = aggregate;
}
public void AggregateBaseConstructor_BadParameters(double costPerKw, double power, bool state)
{
AggregateBase aggregate = new AggregateBase(costPerKw, power, state);
}
public static T LastEvent <T>(this AggregateBase aggregateBase)
{
var aggregate = (IAggregate)aggregateBase;
return((T)aggregate.GetUncommittedEvents().Cast <object>().ToList().Last());
}
public static IEnumerable <Event> GetUncommittedEvents(this AggregateBase ar)
{
IAggregate a = ar;
return(a.GetUncommittedEvents().Cast <Event>());
}
public AggregateEventMedium(AggregateBase <TAggregateId, TEntityId> aggregate) => _aggregate = aggregate;
public Task Save(AggregateBase aggregate)
{
return(_eventSource.AppendEvents(aggregate.AggregateId, aggregate.HydratedEventCount, aggregate.UncommittedEvents));
}
