public static void DeleteSeries(SeriesModel series)
{
using (IDbConnection cnn = new SQLiteConnection(LoadConnectionString()))
{
cnn.Execute("DELETE FROM Series WHERE ID=@ID", series);
}
}
public async Task <BaseResponseMessage> UpdateSeries(SeriesModel series)
{
var newSeries = _mapper.Map <Series>(series);
var response = new BaseResponseMessage();
var seriesToUpdate = await _seriesRepository.GetSeries(newSeries.Id);
if (seriesToUpdate == null)
{
response.RawData = $"Series with {newSeries.Id} wasn't found.";
return(response);
}
if (seriesToUpdate.Equals(newSeries))
{
response.RawData = $"Series {newSeries.Name} already existing with similar data.";
return(response);
}
await _seriesRepository.UpdateSerires(seriesToUpdate);
response.Id = newSeries.Id;
return(response);
}
public static int AddSeries(string connectionString, string title, int debutYear, string filmType, string genre, string language)
{
switch (filmType)
{
case "0":
filmType = "Animation";
break;
case "1":
filmType = "Anime";
break;
case "2":
filmType = "Live Action";
break;
}
SeriesModel series = new SeriesModel
{
Title = title,
DebutYear = debutYear,
FilmType = filmType,
Genre = genre,
Language = language
};
SqlDataAccess sqlDataAccess = new SqlDataAccess();
sqlDataAccess.GetConnectionString(connectionString);
string sql = @"CALL series.usp_Insert_Series(@Title, @DebutYear, @FilmType, @Genre, @Language)";
return(sqlDataAccess.SaveData <SeriesModel>(sql, series));
}
// PUT: api/Series/5
public SeriesModel Put(int id, [FromBody] SeriesModel value)
{
var obj = Mapper.Map <Serie>(value);
var user = repo.Update(obj);
return(Mapper.Map <SeriesModel>(user));
}
public Series[] ModelToSeries(SeriesModel[] seriesModel)
{
var series = new Series[3];
for (var k = 0; k < seriesModel[0].SizeOfSeries; k++)
{
series[k] = new Series();
series[k].a = new DataArray(seriesModel[0].Size);
series[k].SizeOfSeries = seriesModel[k].SizeOfSeries;
series[k].Size = seriesModel[k].Size;
series[k].MOValue = seriesModel[k].MOValue;
for (var i = 0; i < seriesModel[0].Size; i++)
{
var mas = seriesModel[k].items[i];
for (var j = 0; j < 12; j++)
{
series[k].a[i][j] = mas[j];
}
series[k].Name = seriesModel[k].Name;
series[k].activity = seriesModel[k].activity;
series[k].ratio = seriesModel[k].ratio;
series[k].breeding = seriesModel[k].breeding;
}
}
return series;
}
public static List <ItemModel> ConvertToSeriesModel(this List <string> lines)
{
List <ItemModel> output = new List <ItemModel>();
foreach (string line in lines)
{
string[] cols = line.Split(';');
SeriesModel p = new SeriesModel();
p.Title = cols[0];
p.Url = cols[1];
p.PictureUrl = cols[2];
p.PicFormat = int.Parse(cols[3]);
p.Score = decimal.Parse(cols[4]);
p.Year = int.Parse(cols[5]);
p.Favourite = bool.Parse(cols[6]);
p.Notes = cols[7];
p.ListGroup = cols[8];
p.CurrentSe = int.Parse(cols[9]);
p.WatchedEp = int.Parse(cols[10]);
p.TotalSe = int.Parse(cols[11]);
p.TotalEp = cols[12];
p.FinishedRunning = bool.Parse(cols[13]);
output.Add(p);
}
return(output);
}
public EmptyResult Edit(SeriesModel seriesModel)
{
var series = _seriesProvider.GetSeries(seriesModel.SeriesId);
series.Monitored = seriesModel.Monitored;
series.SeasonFolder = seriesModel.SeasonFolder;
series.QualityProfileId = seriesModel.QualityProfileId;
var oldPath = series.Path;
series.Path = seriesModel.Path;
series.BacklogSetting = (BacklogSettingType)seriesModel.BacklogSetting;
if (!String.IsNullOrWhiteSpace(seriesModel.CustomStartDate))
{
series.CustomStartDate = DateTime.Parse(seriesModel.CustomStartDate, null, DateTimeStyles.RoundtripKind);
}
else
{
series.CustomStartDate = null;
}
_seriesProvider.UpdateSeries(series);
if (oldPath != series.Path)
{
_jobProvider.QueueJob(typeof(DiskScanJob), new { SeriesId = series.SeriesId });
}
return(new EmptyResult());
}
public async Task <ActionResult <SeriesModel> > PostSeries([FromBody] SeriesModel Series)
{
_context.Series.Add(Series);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetSeries", new { id = Series.ID }, Series));
}
public async Task <IActionResult> PutSeries(int id, SeriesModel Series)
{
if (id != Series.ID)
{
return(BadRequest());
}
_context.Entry(Series).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SeriesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IActionResult SaveUser([FromBody] SeriesModel model)
{
var msg = new Message <SeriesModel>();
var data = DbClientFactory <SeriesDbClient> .Instance.SaveUser(model, appSettings.Value.DbConn);
if (data == "C200")
{
msg.IsSuccess = true;
if (model.Id == 0)
{
msg.ReturnMessage = "User saved successfully";
}
else
{
msg.ReturnMessage = "User updated successfully";
}
}
else if (data == "C201")
{
msg.IsSuccess = false;
msg.ReturnMessage = "Email Id already exists";
}
else if (data == "C202")
{
msg.IsSuccess = false;
msg.ReturnMessage = "Mobile Number already exists";
}
return(Ok(msg));
}
public SeriesModel[] SeriesToModel(Series[] series)
{
var seriesModel = new SeriesModel[3];
for (var k = 0; k < series[0].SizeOfSeries; k++)
{
seriesModel[k] = new SeriesModel();
seriesModel[k].items = new List<double[]>();
seriesModel[k].SizeOfSeries = series[k].SizeOfSeries;
seriesModel[k].Size = series[k].Size;
seriesModel[k].MOValue = series[k].MOValue;
for (var i = 0; i < series[k].Size; i++)
{
var mas = new double[12];
for (var j = 0; j < 12; j++)
{
mas[j] = series[k].a[i][j];
}
seriesModel[k].items.Add(mas);
seriesModel[k].Name = series[k].Name;
seriesModel[k].activity = series[k].activity;
seriesModel[k].ratio = series[k].ratio;
seriesModel[k].breeding = series[k].breeding;
}
}
return seriesModel;
}
private void MvvmBar_Load(object sender, EventArgs e)
{
Model = new SeriesModel();
barChart1.Series = Model;
barChart1.LegendLocation = LegendLocation.Left;
//if you need a custom tooltip dasly you need to use wpf for now
barChart1.DataTooltip = new LineCustomTooltip();
}
public IHttpActionResult UpdateSeries([FromBody] SeriesModel Serie)
{
SeriesModel series = new SeriesModel();
var SerieModel = new SeriesDataModel();
series = SerieModel.UpdateSeries(Serie);
return(Ok(series));
}
public IHttpActionResult AddSerie([FromBody] SeriesModel Serie)
{
SeriesModel Series = new SeriesModel();
var SerieModel = new SeriesDataModel();
Series = SerieModel.AddSeries(Serie);
return(Ok(Series));
}
public static void UpdateSeries(SeriesModel series)
{
using (IDbConnection cnn = new SQLiteConnection(LoadConnectionString()))
{
cnn.Execute("UPDATE Series SET Title=@Title, Url=@Url, PictureUrl=@PictureUrl, PicFormat=@PicFormat, Score=@Score, Year=@Year, Favourite=@Favourite, Notes=@Notes, " +
"ListGroup=@ListGroup, TotalSe=@TotalSe, CurrentSe=@CurrentSe, TotalEp=@TotalEp, WatchedEp=@WatchedEp, FinishedRunning=@FinishedRunning WHERE ID=@ID", series);
}
}
public static void ImportSeries(SeriesModel series)
{
using (IDbConnection cnn = new SQLiteConnection(LoadConnectionString()))
{
cnn.Execute("INSERT OR IGNORE INTO Series (Title, Url, PictureUrl, PicFormat, Score, Year, Favourite, Notes, ListGroup, TotalSe, CurrentSe, TotalEp, WatchedEp, FinishedRunning) " +
"VALUES (@Title, @Url, @PictureUrl, @PicFormat, @Score, @Year, @Favourite, @Notes, @ListGroup, @TotalSe, @CurrentSe, @TotalEp, @WatchedEp, @FinishedRunning)", series);
}
}
public static SeriesView Map(this SeriesModel source)
=> new SeriesView
{
Id = source.Id,
Name = source.Name,
Description = source.Description,
BookCount = source.BookCount
};
private void DeleteSeriesDetails(SeriesModel dataModel)
{
if (dataModel != null)
{
DataModelProvider.Instance.DeleteSelectedDataModel(dataModel);
GetSavedDataModels();
CreateWpfGraphDataSeries();
}
}
public ActionResult ViewSeries()
{
var series = SeriesModel.GetAllSeries();
if (IsEmpty(series))
{
return(ErrorStatus(HttpStatusCode.InternalServerError, "Error getting series listing"));
}
return(FormatOutput(series));
}
public IActionResult Put([FromBody] SeriesModel updatedSeries)
{
var series = _seriesService.Update(updatedSeries.ToDomainModel());
if (series == null)
{
BadRequest();
}
return(Ok(series));
}
public IActionResult AddSeries(SeriesModel model)
{
if (ModelState.IsValid)
{
int seriesAdded = SeriesProcessor.AddSeries(connectionString, model.Title, model.DebutYear, model.FilmType, model.Genre, model.Language);
return(RedirectToAction("Index"));
}
return(View());
}
public async Task UpdateSeries(int libraryId, SeriesModel series, CancellationToken cancellationToken)
{
using (var connection = _connectionProvider.GetConnection())
{
var sql = @"Update Series Set Name = @Name, [Description] = @Description, ImageId = @ImageId, LibraryId = @LibraryId Where Id = @Id And LibraryId = @LibraryId";
var parameter = new { LibraryId = libraryId, Name = series.Name, Description = series.Description, ImageId = series.ImageId, Id = series.Id };
var command = new CommandDefinition(sql, parameter, cancellationToken: cancellationToken);
await connection.ExecuteScalarAsync <int>(command);
}
}
public IActionResult Post([FromBody] SeriesModel newSeries)
{
var series = _seriesService.Add(newSeries.ToDomainModel());
if (series == null)
{
return(BadRequest());
}
return(CreatedAtAction("Get", new { newSeries.Id }, newSeries));
}
public ActionResult ViewArticlesBySeries(string seriesSlug)
{
var series = SeriesModel.GetSeriesBySlug(seriesSlug);
if (series == null)
{
return(HttpNotFound());
}
return(View(Views.Articles.Index, new ArticlesIndexViewModel(series)));
}
public void RedrawPureComponentChart()
{
var chart = new ChartModel();
chart.Title = SelectedFunctionType.ToString();
chart.XAxisTitle = "Temperature [°C]";
chart.XMin = MinimumTemperature;
chart.XMax = MaximumTemperature;
chart.ShowLegend = true;
chart.AutoScaleY = true;
int steps = 41;
foreach (var comp in ComponentsForPureAnalysis.Where(c => c.IsChecked).Select(c => c.Data))
{
var SelectedFunction = comp.GetFunction(SelectedFunctionType);
chart.YAxisTitle = SelectedFunctionType.ToString() + " [" + SelectedFunction.YUnit + "]";
// RedrawPureComponent(comp.Data);
var T = CurrentSystem.VariableFactory.CreateVariable("T", "Temperature", PhysicalDimension.Temperature);
T.OutputUnit = METRIC.C;
var funcExpr = CurrentSystem.CorrelationFactory.CreateExpression(SelectedFunction.Type, SelectedFunction, T, comp.GetConstant(ConstantProperties.CriticalTemperature), comp.GetConstant(ConstantProperties.CriticalPressure));
double maxVal = 1e20;
if (SelectedFunction.Property == EvaluatedProperties.VaporPressure)
{
var funcExprMax = CurrentSystem.CorrelationFactory.CreateExpression(SelectedFunction.Type, SelectedFunction, comp.GetConstant(ConstantProperties.CriticalTemperature), comp.GetConstant(ConstantProperties.CriticalTemperature), comp.GetConstant(ConstantProperties.CriticalPressure));
maxVal = funcExprMax.Eval(new Evaluator());
}
var eval = new Evaluator();
List <double> yValues = new List <double>();
List <double> xValues = new List <double>();
for (int i = 0; i < steps; i++)
{
eval.Reset();
T.SetValue(MinimumTemperature + (MaximumTemperature - MinimumTemperature) / (double)steps * i, METRIC.C);
var y = funcExpr.Eval(eval);
if (Double.IsNaN(y))
{
y = 0;
}
// if (y > maxVal)
// y = maxVal;
xValues.Add(T.ValueInOutputUnit);
yValues.Add(y);
}
var ySeries = new SeriesModel(comp.ID + " " + SelectedFunction.Property.ToString(), SeriesType.Line, xValues, yValues, "Auto");
chart.Series.Add(ySeries);
}
PureComponentPropertyChart = _chartFactory.Create(chart);
}
public EditSeriesViewModel(string slug)
{
if (slug != null)
{
this.Series = SeriesModel.GetSeriesBySlug(slug);
}
else
{
this.Series = new SeriesModel();
}
}
// POST: api/Series
public SeriesModel Post([FromBody] SeriesModel value)
{
if (value == null)
{
return(null);
}
var obj = Mapper.Map <Serie>(value);
var series = repo.Insert(obj);
return(Mapper.Map <SeriesModel>(series));
}
private void SaveSeriesDetails(SeriesModel dataModel)
{
if (dataModel != null)
{
var matchedColor = AllColors.Where(x => x.ColorName == dataModel.ColorInfo.ColorName).FirstOrDefault();
dataModel.ColorInfo.Color = matchedColor.Color;
DataModelProvider.Instance.SaveSelectedDataModel(dataModel);
Console.WriteLine(dataModel);
GetSavedDataModels();
CreateWpfGraphDataSeries();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ChartPanel" /> class.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="seriesconfig">The seriesconfig.</param>
public ChartPanel(IEnumerable <DataRow> data, ISeriesConfig seriesconfig)
: this()
{
SourceModel = new SourceModel(data, seriesconfig);
Configuration = SourceModel.GetSeriesConfiguration();
ChartData = new SeriesModel(data, seriesconfig);
DataMetric = SourceModel.GetMetric();
TitleInfo = new TitleInfo(DataMetric.Data?.CopyToDataTable()?.TableName);
DataSeries = new DataSeries(ChartData);
Series.Add(DataSeries);
Titles.Add(TitleInfo.GetChartMainTitle());
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="ChartPanel" />
/// class.
/// </summary>
/// <param name="sourcebinding">The sourcebinding.</param>
public ChartPanel(IChartBinding sourcebinding)
: this()
{
SourceModel = new SourceModel(sourcebinding);
Configuration = SourceModel.GetSeriesConfiguration();
ChartData = new SeriesModel(sourcebinding);
DataMetric = SourceModel.GetMetric();
TitleInfo = new TitleInfo(DataMetric.Data?.CopyToDataTable()?.TableName);
DataSeries = new DataSeries(ChartData);
Series.Add(DataSeries);
Titles.Add(TitleInfo.GetChartMainTitle());
}
public ActionResult ViewArticlesBySeriesAndMonth(int year, int month, string seriesSlug)
{
var date = new DateTime(year, month, 1);
var series = SeriesModel.GetSeriesBySlug(seriesSlug);
if (series == null)
{
return(HttpNotFound());
}
return(View(Views.Articles.Index, new ArticlesIndexViewModel(series, date)));
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="ChartPanel" />
/// class.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="title">The title.</param>
public ChartPanel(ISourceModel model, ITitleInfo title)
: this()
{
SourceModel = model;
Configuration = SourceModel.GetSeriesConfiguration();
TitleInfo = title;
DataMetric = SourceModel.GetMetric();
ChartData = new SeriesModel(SourceModel.GetSourceBinding());
DataSeries = new DataSeries(ChartData);
Series.Add(DataSeries);
Titles.Add(TitleInfo.GetChartMainTitle());
}
public void Save(string fileName, params Series[] series)
{
var seriesModel = new SeriesModel[3];
seriesModel = SeriesToModel(series);
var serializer = new XmlSerializer(typeof (SeriesModel[]));
using (TextWriter textWriter = new StreamWriter(fileName))
{
serializer.Serialize(textWriter, seriesModel);
}
}
private void CreateDataModels()
{
DataModelsCount++;
SeriesModel dataModel = new SeriesModel();
dataModel.Id = DataModelsCount;
dataModel.SeriesName = "Var " + DataModelsCount;
dataModel.ColorInfo.SetRandomColor(DataModelsCount);
DataModelProvider.Instance.DataModels.Add(dataModel);
DataModelProvider.Instance.SaveDataModels();
GetSavedDataModels();
CreateWpfGraphDataSeries();
}
