protected override async Task OnInitializedAsync()
{
this.FormId = this.Parameters.Get <int>("FormId");
this.Id = this.Parameters.TryGet <int>("series");
((ModalService)this.ModalService).OnConfirm += this.OnConfirm;
this.Model = new SeriesModel
{
Title = "",
Description = "",
StartYear = null,
EndYear = null
};
this.Context = new EditContext(this.Model);
if (this.Id != 0)
{
this.Series = await this.SeriesService.Get(this.Id);
this.Model = new SeriesModel(this.Series);
this.IsEdit = true;
this.Context = new EditContext(this.Model);
}
}
internal BookView BuildView()
{
var fixture = new Fixture();
if (Author == null)
{
Author = _authorBuilder.WithLibrary(_libraryId).Build(1).Single();
}
SeriesDto series = _series;
if (_hasSeries && _series == null)
{
series = _seriesBuilder.WithLibrary(_libraryId).Build();
}
return(fixture.Build <BookView>()
.With(b => b.Authors, new List <AuthorView> {
new AuthorView {
Id = Author.Id
}
})
.With(b => b.SeriesId, series.Id)
.With(b => b.SeriesIndex, RandomData.Number)
.With(b => b.Categories, _categories.Any() ? _categories.Select(c => c.ToView()) : new CategoryView[0])
.With(b => b.Language, RandomData.Locale)
.Create());
}
public SeriesAssert ShouldHaveCorrectSeriesRetunred(SeriesDto series, IDbConnection dbConnection)
{
_series.Should().NotBeNull();
_series.Id.Should().Be(series.Id);
_series.Name.Should().Be(series.Name);
_series.BookCount.Should().Be(dbConnection.GetBookCountBySeries(_series.Id));
return(this);
}
public async Task Setup()
{
var series = SeriesBuilder.WithLibrary(LibraryId).WithBooks(3).Build(4);
_expected = series.PickRandom();
_response = await Client.DeleteAsync($"/libraries/{LibraryId}/series/{_expected.Id}");
}
/// <summary>
/// Model from series data object
/// </summary>
/// <param name="series">Series data object</param>
public SeriesModel(SeriesDto series)
{
this.Title = series.Title;
this.Description = series.Description;
this.StartYear = series.StartYear;
this.EndYear = series.EndYear;
this.TrailerUrl = series.TrailerUrl;
}
public async Task Setup()
{
_series = SeriesBuilder.WithLibrary(LibraryId).Build();
_SeriesBooks = BookBuilder.WithLibrary(LibraryId).WithSeries(_series).IsPublic().Build(25);
SeriesBuilder.WithLibrary(LibraryId).WithBooks(3).Build();
_response = await Client.GetAsync($"/libraries/{LibraryId}/books?pageNumber=4&pageSize=10&seriesid={_series.Id}");
_assert = new PagingAssert <BookView>(_response);
}
public async Task Setup()
{
var series = SeriesBuilder.WithLibrary(LibraryId).Build(4);
_expected = series.PickRandom();
_response = await Client.GetAsync($"/libraries/{LibraryId}/series/{_expected.Id}");
_assert = SeriesAssert.WithResponse(_response).InLibrary(LibraryId);
}
static void Main(string[] args)
{
var dto = new SeriesDto();
dto.Data.Add("A string");
dto.Data.Add(1001);
dto.Data.Add(new TimeSpan(0, 0, 15));
var list = new HighchartsDto();
list.Series.Add(dto);
TimeSpan time = (TimeSpan)list.Series[0].Data[2]; // 15 seconds
}
public void PostSeries([FromBody] SeriesDto seriesDto)
{
Series com = new Series();
com.Id = seriesDto.Id;
com.OpenTime = seriesDto.OpenTime;
com.CloseTime = seriesDto.CloseTime;
com.PreMoney = seriesDto.PreMoney;
com.PostMoney = seriesDto.PostMoney;
com.CompanyId = seriesDto.CompanyId;
stocky.Series.Add(com);
stocky.SaveChanges();
}
static void Main(string[] args)
{
var a = new StringData("A");
var b = new IntegerData(1001);
var dto = new SeriesDto();
dto.Data.Add(a);
dto.Data.Add(b);
var list = new HighchartsDto();
list.Series.Add(dto);
DateTime time = list.Series[0].Data[0].CreatedTime; // time
}
public void PutSeries(String id, [FromBody] SeriesDto seriesDto)
{
// stocky.Company.Update(id, com);
Series com = stocky.Series.Where(e => e.Id == seriesDto.Id).Single <Series>();
com.Id = seriesDto.Id;
com.OpenTime = seriesDto.OpenTime;
com.CloseTime = seriesDto.CloseTime;
com.PreMoney = seriesDto.PreMoney;
com.PostMoney = seriesDto.PostMoney;
com.CompanyId = seriesDto.CompanyId;
stocky.Entry(com).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
stocky.SaveChanges();
}
public async Task Setup()
{
_series = SeriesBuilder.WithLibrary(LibraryId).Build();
var books = BookBuilder.WithLibrary(LibraryId).WithSeries(_series).Build(1);
_bookToUpdate = books.PickRandom();
var book = new BookView {
Title = RandomData.Text, SeriesId = -RandomData.Number
};
_response = await Client.PutObject($"/libraries/{LibraryId}/books/{_bookToUpdate.Id}", book);
}
public async Task Setup()
{
_series = SeriesBuilder.WithLibrary(LibraryId).Build();
_seriesBooks = BookBuilder.WithLibrary(LibraryId)
.WithSeries(_series)
.IsPublic()
.AddToFavorites(AccountId)
.Build(5);
SeriesBuilder.WithLibrary(LibraryId).WithBooks(3).Build();
_response = await Client.GetAsync($"/libraries/{LibraryId}/books?pageNumber=1&pageSize=10&favorite=true");
_assert = new PagingAssert <BookView>(_response);
}
public async Task WriteSwSeriesToSS(SwObjects.Series series)
{
_club = await GetClub();
_boatClass = await GetBoatClass();
_fleet = await GetFleet();
_season = await GetSeason();
_series = await MakeSeries(series);
_competitors = await GetCompetitors(series);
await SaveRaces(series);
}
public IHttpActionResult CreateSeries(SeriesDto seriesDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var series = Mapper.Map <SeriesDto, Series>(seriesDto);
_context.Series.Add(series);
_context.SaveChanges();
seriesDto.Id = series.Id;
return(Created(new Uri(Request.RequestUri + "/" + seriesDto.Id), seriesDto));
}
public async Task <ActionResult <Guid> > Post([FromBody] SeriesDto series)
{
if (!await _authService.CanUserEdit(User, series.ClubId))
{
return(Unauthorized());
}
var seriesBizObj = _mapper.Map <Series>(series);
await _service.SaveNewSeries(seriesBizObj);
var savedSeries =
(await _service.GetAllSeriesAsync(series.ClubId, null, true))
.Single(s => s.Name == series.Name &&
s.Season.Id == series.SeasonId);
return(Ok(savedSeries.Id));
}
/// <inheritdoc cref="IUpdatable{TDto}.UpdateAsync(TDto)"/>
public async Task <SeriesDto> UpdateAsync(SeriesDto dto)
{
using var scope = await _uow.DbContext.Database.BeginTransactionAsync();
try
{
var series = await _uow.seriesRepository.UpdateAsync(dto);
scope.Commit();
return(series);
}
catch (Exception ex)
{
scope.Rollback();
throw ex;
}
}
public IHttpActionResult UpdateSeries(int id, SeriesDto seriesDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var seriesInDb = _context.Series.SingleOrDefault(s => s.Id == id);
if (seriesInDb == null)
{
return(NotFound());
}
Mapper.Map(seriesDto, seriesInDb);
_context.SaveChanges();
return(Ok());
}
public async Task Setup()
{
_library2Builder = Services.GetService <LibraryDataBuilder>();
var library2 = _library2Builder.Build();
var series2 = SeriesBuilder.WithLibrary(library2.Id).Build();
_series = SeriesBuilder.WithLibrary(LibraryId).Build();
var books = BookBuilder.WithLibrary(LibraryId).WithSeries(_series).Build(1);
_bookToUpdate = books.PickRandom();
var book = new BookView {
Title = RandomData.Text, SeriesId = series2.Id
};
_response = await Client.PutObject($"/libraries/{LibraryId}/books/{_bookToUpdate.Id}", book);
}
static void Main(string[] args)
{
var a = new SeriesDto <string>();
a.Data.Add("A");
a.Data.Add("B");
a.Data.Add("C");
var b = new SeriesDto <string>();
b.Data.Add("1");
b.Data.Add("2");
b.Data.Add("3");
var list = new HighChartsStringDto();
list.Series.Add(a);
list.Series.Add(b);
string x = list.Series[1].Data[2]; // "C"
}
public dynamic GetSeries(String companyID)
{
List <Series> series;
List <SeriesDto> seriesDtos = new List <SeriesDto>();
if (companyID != null)
{
series = stocky.Series.Where(e => e.CompanyId == companyID).ToList();
}
else
{
series = stocky.Series.ToList();
}
foreach (Series seri in series)
{
SeriesDto dto = new SeriesDto(
seri.Id, seri.OpenTime, seri.CloseTime, seri.PreMoney, seri.PostMoney, seri.CompanyId);
seriesDtos.Add(dto);
}
return(seriesDtos);
}
///<inheritdoc cref="ICreatable{TDto}.CreateAsync(TDto)"/>
public async Task <GameDto> CreateAsync(GameDto dto)
{
using var scope = await _uow.DbContext.Database.BeginTransactionAsync();
try
{
SeriesDto series = await _uow.seriesRepository.GetAsync(dto.Series.Name);
ICollection <GameGenreDto> gameGenre = dto.GameGenres;
if (null != series)
{
dto.Series = null;
dto.SeriesId = series.Id;
}
foreach (GameGenreDto gg in gameGenre)
{
GenreDto genre = await _uow.genreRepository.GetAsync(gg.Genre.Name);
if (null != genre)
{
gg.Genre = null;
gg.GenreId = genre.Id;
}
gg.Game = dto;
}
var game = await _uow.gameRepository.CreateAsync(dto);
scope.Commit();
return(game);
}
catch (Exception ex)
{
scope.Rollback();
throw ex;
}
}
private async Task <SeriesDto> MakeSeries(SwObjects.Series series)
{
Console.Write("What is the name of this series? > ");
var result = Console.ReadLine();
var seriesDto = new SeriesDto
{
ClubId = _club.Id,
Name = result,
SeasonId = _season.Id
};
try
{
var guid = await _apiClient.SaveSeries(seriesDto);
seriesDto.Id = guid;
}
catch (Exception ex)
{
Console.WriteLine($"Oh Noes! There was an exception: {ex}");
throw;
}
return(seriesDto);
}
public IActionResult Update(SeriesDto seriesDto)
{
var series = _seriesService.Update(_mapper.Map <Series>(seriesDto));
return(NoContent());
}
public async Task <IActionResult> Save(SeriesDto seriesDto)
{
var newSeries = await _seriesService.AddAsync(_mapper.Map <Series>(seriesDto));
return(Created(string.Empty, _mapper.Map <SeriesDto>(newSeries)));
}
public async Task Should_apply_traits()
{
var series = new SeriesDto();
series.Id.Value.Should().BeEmpty();
series.Created.Should().Be(default);
public async Task <Guid> SaveSeries(SeriesDto series)
{
return(await PostAsync <SeriesDto>($"/api/series/", series));
}
public static void AddSeries(this IDbConnection connection, SeriesDto series)
{
var id = connection.ExecuteScalar <int>("Insert Into Series (Name, [Description], ImageId, LibraryId) OUTPUT Inserted.Id VALUES (@Name, @Description, @ImageId, @LibraryId)", series);
series.Id = id;
}
public static ChartDto ToChartDto(this Plotting.Chart chart, string title = "")
{
var dto = new ChartDto
{
ForcedEveryNthCycle = chart.ForcedEveryNthCycle,
Points = chart.Series
.Select((series, index) => new { series, index })
.SelectMany(item =>
item.series.Points
.Where(p => !double.IsNaN(p.Y))
.Select(p => new Dictionary <string, double?>
{
{ "x", p.X },
{ item.series.IsZAxis ? "z1" : $"y{item.index}", p.Y },
{ "highError", p.HighError.GetValueOrDefault(p.Y) },
{ "lowError", p.LowError.GetValueOrDefault(p.Y) },
{ "discrete", p.Discrete }
}))
.ToList(),
PlotParameters = chart.PlotParameters
};
var yAxisTextNonNull = chart.PlotParameters.yAxisText.Where(text => !string.IsNullOrWhiteSpace(text)).ToList();
dto.Series = chart.Series.Select((series, index) => new { series, index })
// IMPORTANT: there is a problem with empty series, let's remove them temporarily.
// https://github.com/agafonovslava/dqdv/issues/23
// https://www.devexpress.com/Support/Center/Question/Details/T557040/chart-sets-vertical-range-incorrectly-when-using-aggregation
.Where(item => item.series.Points != null && item.series.Points.Count != 0)
.Select(item =>
{
var seriesDto = new SeriesDto();
seriesDto.Id = $"{item.series.ProjectId}_{item.series.DisplayName}";
seriesDto.ProjectId = item.series.ProjectId;
seriesDto.Name = item.series.DisplayName;
seriesDto.ValueField = item.series.IsZAxis ?
"z1" :
$"y{item.index}";
seriesDto.Axis = item.series.IsZAxis ?
$"z1" :
null;
return(seriesDto);
})
.ToList();
dto.Projects = chart.Projects
.Select(p =>
new ProjectDto
{
Id = p.Id,
Name = p.Name,
IsAveragePlot = p.IsAveragePlot
})
.ToList();
dto.ProjectIds = chart.Projects.Select(p => p.Id).ToList();
dto.YAxisText = yAxisTextNonNull.Count > 0 ?
yAxisTextNonNull.ToArray() :
chart.YAxisText.ToArray();
dto.Label = chart.Label;
dto.XAxisIsInteger = chart.XAxisIsInteger;
dto.SelectedTemplateName = chart.SelectedTemplateName;
dto.XAxisText = string.IsNullOrEmpty(chart.PlotParameters.xAxisText) ?
chart.XAxisText :
chart.PlotParameters.xAxisText;
dto.Title = string.IsNullOrEmpty(chart.PlotParameters.ChartTitle) ?
title :
chart.PlotParameters.ChartTitle;
return(dto);
}
public BooksDataBuilder WithSeries(SeriesDto series)
{
_series = series;
return(this);
}
