public ActionResult EditPiece(int IndividualPieceId)
{
using (DataStoreContext db = new DataStoreContext())
{
var pieces = (from aw in db.ArtWork
join ip in db.IndividualPiece
on aw.ArtWorkId equals ip.ArtWorkId
where ip.IndividualPieceId == IndividualPieceId
select new PieceViewModel
{
IndividualPieceId = ip.IndividualPieceId,
Title = aw.Title,
Cost = ip.Cost,
AskingPrice = ip.Price,
Sold = ip.Sold
}).ToList();
PieceViewModel pieceForEdit = new PieceViewModel
{
Title = pieces.Select(p => p.Title).FirstOrDefault(),
Cost = pieces.Select(p => p.Cost).FirstOrDefault(),
AskingPrice = pieces.Select(p => p.AskingPrice).FirstOrDefault(),
Sold = pieces.Select(p => p.Sold).FirstOrDefault()
};
return(View(pieceForEdit));
}
}
public ActionResult CreatePiece(PieceViewModel pieces)
{
using (DataStoreContext db = new DataStoreContext())
{
if (ModelState.IsValid)
{
var matchingArtWork = db.ArtWork.First(a => a.Title == pieces.Title).ArtWorkId;
if (matchingArtWork > 0)
{
IndividualPiece piece = new IndividualPiece
{
ArtWorkId = matchingArtWork,
Image = pieces.Image,
Price = pieces.AskingPrice,
Cost = pieces.Cost,
Sold = pieces.Sold,
EditionNumber = pieces.EditionNumber,
Location = pieces.Location,
InvoiceId = null
};
db.IndividualPiece.Add(piece);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ViewBag.Title = "Our system currently only supports adding new prints of existing art.";
}
}
return(View(pieces));
}
}
public IActionResult Put(string id, [FromBody] PieceViewModel piece)
{
if (id == null || piece == null || !this.ModelState.IsValid)
{
return(this.BadRequest());
}
this.manager.Update(id, piece);
return(this.Ok());
}
public IActionResult Post([FromBody] PieceViewModel piece)
{
if (piece == null || !this.ModelState.IsValid)
{
return(this.BadRequest());
}
this.manager.Create(piece);
return(this.Ok());
}
public async Task Create_WorksProperly()
{
var service = await this.CreatePieceService(new List <Piece>());
var expected = new PieceViewModel()
{
Name = "Test",
Performer = "Test",
PieceType = PieceType.AlbumPiece.ToString(),
Genre = Genre.HipHop.ToString()
};
var created = service.Create(expected);
Assert.AreEqual(created.Name, expected.Name);
}
public async Task Create_WorksProperly()
{
var controller = await this.CreatePieceControllerAsync(new List <Piece>());
var piece = new PieceViewModel()
{
Name = "TestPiece",
Genre = Genre.Pop.ToString(),
Performer = "Test",
PieceType = PieceType.AlbumPiece.ToString()
};
var result = controller.Post(piece);
Assert.AreEqual(typeof(OkResult), result.GetType());
}
public async Task Update_WorksProperly()
{
var service = await this.CreatePieceService(new List <Piece>());
var expected = new PieceViewModel()
{
Name = "Test",
Performer = "Test",
PieceType = PieceType.AlbumPiece.ToString(),
Genre = Genre.HipHop.ToString()
};
var created = service.Create(expected);
expected.Name = "TestUpdated";
service.Update(created.Name, expected);
Assert.NotNull(service.GetAll().Where(x => x.Name == expected.Name));
}
private bool UpdateGameState(bool differentThread)
{
int fromRow = this.fromSquare / 8;
int toRow = this.toSquare / 8;
int fromCol = this.fromSquare % 8;
int toCol = this.toSquare % 8;
Point fromPosition = new Point(fromCol, fromRow);
Point toPosition = new Point(toCol, toRow);
PieceViewModel movingPiece = this.pieces.FirstOrDefault(piece =>
piece.Position.X == fromPosition.X &&
piece.Position.Y == fromPosition.Y);
movingPiece.Position = toPosition;
this.BindPieces(differentThread);
return(this.IsGameOver());
}
public ActionResult EditPiece(PieceViewModel pieces)
{
using (DataStoreContext db = new DataStoreContext())
{
var piece = db.IndividualPiece.Find(pieces.IndividualPieceId);
if (ModelState.IsValid)
{
piece.Cost = pieces.Cost;
piece.Price = pieces.AskingPrice;
piece.Sold = pieces.Sold;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(pieces));
}
}
public Piece Create(PieceViewModel model)
{
Object pieceType;
Object Genre;
Enum.TryParse(typeof(PieceType), model.PieceType, out pieceType);
Enum.TryParse(typeof(Genre), model.Genre, out Genre);
var piece = new Piece()
{
Name = model.Name,
Artist = this.artistRepository.GetByName(model.Performer),
PieceType = (PieceType)pieceType,
Genre = (Genre)Genre,
};
this.pieceRepository.Add(piece);
return(piece);
}
private void BindPieces()
{
this.pieces.Clear();
for (int square = 0; square < this.chessboard.Board.Length; square++)
{
int row = square / 8;
int col = square % 8;
int x = (this.playerColor == Engine.Defaults.Color.White) ? col : Math.Abs(col - 7);
int y = (this.playerColor == Engine.Defaults.Color.White) ? row : Math.Abs(row - 7);
Point position = new Point(x, y);
PieceViewModel pieceModel = new PieceViewModel()
{
PieceType = this.chessboard.Board[square].OccupiedBy.Type,
Color = this.chessboard.Board[square].OccupiedBy.Color,
Position = position
};
this.pieces.Add(pieceModel);
}
this.ChessboardUI.ItemsSource = this.pieces;
}
private ProductivityVueModel GetVueModel(List <EfficiencyStateMachineModel> operatorActivities, MachineInfoModel machine, PeriodModel period)
{
var result = new ProductivityVueModel();
if (machine.MachineTypeId == (int)enMachineType.CentroLavoro || machine.MachineTypeId == (int)enMachineType.LineaTaglio ||
(machine.MachineTypeId == (int)enMachineType.LineaTaglioLavoro))
{
result.currentState = GetCurrentState(machine.Id);
}
var data = _pieceService.GetAggregationPieces(machine, period, enDataType.Dashboard);
//var operatorActivities =_stateService.GetOperatorsActivity(machine, period.StartDate, period.EndDate);
if (data.Count == 0)
{
return(result);
}
// tempo lordo: devo andare sulla tabella degli stati perchè non ce l'ho sui pezzi
var grossTime = operatorActivities.Sum(m => m.TotalTime);
var netTime = operatorActivities.Sum(m => m.ProducingTime);
var productionTime = operatorActivities.Sum(m => m.ProducionModeTime ?? 0);
//var grossTime = data.Select(s => s.ElapsedTime).Sum();
var doneCount = data.Select(s => s.CompletedCount).Sum() ?? 0;
var redoneCount = data.Select(s => s.RedoneCount).Sum() ?? 0;
// kpi pezzi all'ora
var ratio = Common.GetRatioProductivity(doneCount, grossTime);
result.kpi = CommonViewService.getKpiViewModel(ratio, machine.PiecesProductivityGreenThreshold, machine.PiecesProductivityYellowThreshold);
// pieces
var piece = new PieceViewModel();
piece.total = doneCount + redoneCount;
var done = new ProdDataModel();
done.perc = Common.GetPercentage(doneCount, piece.total);
done.number = doneCount;
piece.done = done;
var redone = new ProdDataModel();
redone.perc = Common.GetPercentage(redoneCount, piece.total);
redone.number = redoneCount;
piece.redone = redone;
result.piece = piece;
// materials
var dataBars = _barService.GetAggregationBar(machine, period);
if (dataBars.Count > 0)
{
var barLength = dataBars.Select(s => s.Length ?? 0).Sum().RoundToInt();
double cutoffLength = dataBars.Select(s => s.OffcutLength ?? 0).Sum();
var totalLength = barLength + cutoffLength;
var material = new MaterialViewModel();
material.total = (totalLength / 1000);
var bar = new ProdDataModel();
bar.perc = Common.GetPercentage(barLength, totalLength);
bar.number = ((double)barLength / 1000);
material.bar = bar;
//Nelle troncatrici questi dati sono nascosti, non ci sono,
//per le altre è da verificare cosa prendono
var cutoff = new ProdDataModel();
cutoff.perc = Common.GetPercentage(cutoffLength, totalLength);
cutoff.number = ((double)cutoffLength / 1000);
material.cutoff = cutoff;
result.material = material;
}
// phases
var phases = new List <ProdDataModel>();
switch (machine.MachineTypeId)
{
case (int)enMachineType.Troncatrice:
case (int)enMachineType.LineaTaglio:
var cut = new ProdDataModel();
cut.text = Resource.Cut;
cut.perc = Common.GetPercentage(netTime, grossTime);
phases.Add(cut);
break;
case (int)enMachineType.CentroLavoro:
var working = new ProdDataModel();
working.text = Resource.Working;
working.perc = Common.GetPercentage(productionTime, grossTime);
phases.Add(working);
break;
default:
working = new ProdDataModel();
working.text = Resource.Working;
working.perc = Common.GetPercentage(data.Select(s => s.ElapsedTimeWorking ?? 0).Sum(), grossTime);
phases.Add(working);
var trim = new ProdDataModel();
trim.text = Resource.Trim;
trim.perc = Common.GetPercentage(data.Select(s => s.ElapsedTimeTrim ?? 0).Sum(), grossTime);
phases.Add(trim);
cut = new ProdDataModel();
cut.text = Resource.Cut;
cut.perc = Common.GetPercentage(data.Select(s => s.ElapsedTimeCut ?? 0).Sum(), grossTime);
phases.Add(cut);
break;
}
result.phases = phases.OrderByDescending(o => o.perc).ToList();
// operators
//var dataOperators = _pieceService.GetAggregationPieces(machine, period, enDataType.Operators);
var dataOperators = operatorActivities;
if (dataOperators.Count > 0)
{
var groupOperator = dataOperators.GroupBy(g => new { g.Operator, g.TotalTime }).OrderByDescending(x => x.Key.TotalTime).ToList();
if (groupOperator.Count <= 3)
{
result.operators = groupOperator.Select(o => new ProdDataModel()
{
text = o.Key.Operator,
perc = Common.GetPercentage(o.Key.TotalTime ?? 0, grossTime)
}).OrderByDescending(p => p.perc).ToList();
}
else
{
var firstGroup = groupOperator.GetRange(0, 2);
var secondGroup = groupOperator.GetRange(2, groupOperator.Count - 2);
if (firstGroup.Count > 0)
{
result.operators = firstGroup.Select(o => new ProdDataModel()
{
text = o.Key.Operator,
perc = Common.GetPercentage(o.Key.TotalTime ?? 0, grossTime)
}).OrderByDescending(p => p.perc).ToList();
}
if (secondGroup.Count > 0)
{
var elpasedTimeTotal = secondGroup.Select(s => s.Key.TotalTime ?? 0).Sum();
result.operators.Add(new ProdDataModel()
{
text = Resource.Others,
perc = Common.GetPercentage(elpasedTimeTotal, grossTime)
});
}
}
}
// gross time
result.time = CommonViewService.getTimeViewModel(grossTime);
return(result);
}
public void Update(string id, PieceViewModel piece)
{
this.pieceRepository.HardDelete(this.pieceRepository.GetByName(id));
this.Create(piece);
}
