Samuele Locatelli
382 lines
12 KiB
C#
382 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.AspNetCore.Components;
|
|
using System.Net.Http;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Components.Authorization;
|
|
using Microsoft.AspNetCore.Components.Forms;
|
|
using Microsoft.AspNetCore.Components.Routing;
|
|
using Microsoft.AspNetCore.Components.Web;
|
|
using Microsoft.AspNetCore.Components.Web.Virtualization;
|
|
using Microsoft.JSInterop;
|
|
using GPW.CORE.Comp;
|
|
using GPW.CORE.Data.DbModels;
|
|
using GPW.CORE.Smart;
|
|
using GPW.CORE.Smart.Components;
|
|
using GPW.CORE.Smart.Shared;
|
|
using GPW.CORE.Smart.Data;
|
|
using NLog;
|
|
using System.Diagnostics;
|
|
|
|
namespace GPW.CORE.Smart.Components
|
|
{
|
|
public partial class RegAttEditor
|
|
{
|
|
#region Protected Fields
|
|
|
|
protected string _gruppoSel = "";
|
|
protected int _idxProj = 0;
|
|
protected bool vetoUpd = false;
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Private Properties
|
|
|
|
[Inject]
|
|
private MessageService AppMServ { get; set; } = null!;
|
|
|
|
[Inject]
|
|
private IJSRuntime JSRuntime { get; set; } = null!;
|
|
|
|
private bool VetoInsert
|
|
{
|
|
get => CDService.VetoInsert;
|
|
}
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Protected Properties
|
|
|
|
protected List<AnagFasiModel> fasiList { get; set; } = new List<AnagFasiModel>();
|
|
|
|
[Inject]
|
|
protected CoreSmartDataService CDService { get; set; } = null!;
|
|
|
|
protected List<AnagGruppiModel> gruppiList { get; set; } = new List<AnagGruppiModel>();
|
|
protected List<AnagProgettiModel> projList { get; set; } = new List<AnagProgettiModel>();
|
|
|
|
#endregion Protected Properties
|
|
|
|
#region Public Properties
|
|
|
|
|
|
private static Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
[Parameter]
|
|
public RegAttivitaModel? currRecord
|
|
{
|
|
get
|
|
{
|
|
return AppMServ.recordRA;
|
|
}
|
|
set
|
|
{
|
|
AppMServ.recordRA = value;
|
|
vetoUpd = true;
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
|
|
var updFase = Task.Run(async () =>
|
|
{
|
|
if (value != null)
|
|
{
|
|
if (value.FasiNav != null && value.FasiNav.ProgettoNav != null)
|
|
{
|
|
gruppoSel = value.FasiNav.ProgettoNav.Gruppo;
|
|
idxProj = value.FasiNav.IdxProgetto != null ? (int)value.FasiNav.IdxProgetto : 0;
|
|
}
|
|
else
|
|
{
|
|
|
|
// effettuo selezione manuale...
|
|
var currFase = await CDService.AnagFasiByKey(value.IdxFase);
|
|
if (currFase != null)
|
|
{
|
|
if (currFase.ProgettoNav != null)
|
|
{
|
|
gruppoSel = currFase.ProgettoNav.Gruppo;
|
|
}
|
|
idxProj = currFase.IdxProgetto != null ? (int)currFase.IdxProgetto : 0;
|
|
}
|
|
value.IdxFase = 0;
|
|
}
|
|
}
|
|
await ReloadData(false, false);
|
|
});
|
|
updFase.Wait();
|
|
|
|
stopWatch.Stop();
|
|
TimeSpan ts = stopWatch.Elapsed;
|
|
|
|
Log.Trace($"Test esecuzione sel cascata: {ts.TotalMilliseconds} ms");
|
|
vetoUpd = false;
|
|
}
|
|
}
|
|
|
|
public string gruppoSel
|
|
{
|
|
get
|
|
{
|
|
return _gruppoSel;
|
|
}
|
|
set
|
|
{
|
|
_gruppoSel = value;
|
|
if (!vetoUpd)
|
|
{
|
|
var pUpd = Task.Run(async () => await ReloadData(true, true));
|
|
pUpd.Wait();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected int idxFase
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
if (currRecord != null)
|
|
{
|
|
answ = currRecord.IdxFase;
|
|
}
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
if (currRecord != null)
|
|
{
|
|
currRecord.IdxFase = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public int idxProj
|
|
{
|
|
get
|
|
{
|
|
return _idxProj;
|
|
}
|
|
set
|
|
{
|
|
_idxProj = value;
|
|
if (!vetoUpd)
|
|
{
|
|
var pUpd = Task.Run(async () => await ReloadData(false, true));
|
|
pUpd.Wait();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Parameter]
|
|
public EventCallback<bool> ItemReset { get; set; }
|
|
|
|
[Parameter]
|
|
public EventCallback<bool> ItemUpdated { get; set; }
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Private Methods
|
|
|
|
private void arrotondaMinuti()
|
|
{
|
|
if (currRecord != null)
|
|
{
|
|
// arrotondo ai 5 min...
|
|
currRecord.Inizio = CORE.Data.Utils.DateRounded(currRecord.Inizio.AddMinutes(2), 5, true);
|
|
// arrotondo ai 5 min...
|
|
currRecord.Fine = CORE.Data.Utils.DateRounded(currRecord.Fine.AddMinutes(2), 5, true);
|
|
checkCoerenzaDate(true);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifico coerenza date (inizio < fine)
|
|
/// </summary>
|
|
/// <param name="modInizio">indica se la data modificata sia l'inizio</param>
|
|
private void checkCoerenzaDate(bool modInizio)
|
|
{
|
|
bool inError = false;
|
|
// verifica presenza errori
|
|
if (currRecord != null)
|
|
{
|
|
inError = currRecord.Inizio >= currRecord.Fine;
|
|
if (inError)
|
|
{
|
|
// se ho mod inizio --> tengo ferma fine, inizio 1/2 h prima
|
|
if (modInizio)
|
|
{
|
|
currRecord.Inizio = currRecord.Fine.AddMinutes(-30);
|
|
}
|
|
else
|
|
{
|
|
currRecord.Fine = currRecord.Inizio.AddMinutes(30);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// Salvo in MService record clonato
|
|
/// </summary>
|
|
protected async void DoClone()
|
|
{
|
|
if (currRecord != null)
|
|
{
|
|
var newData = currRecord.Clone();
|
|
newData.IdxRa = 0;
|
|
AppMServ.clonedRA = newData;
|
|
await ItemReset.InvokeAsync(true);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimino record
|
|
/// </summary>
|
|
protected async void DoDelete()
|
|
{
|
|
// chiedo verifica
|
|
if (!await JSRuntime.InvokeAsync<bool>("confirm", "Sicuro di voler eliminare il record selezionato??"))
|
|
return;
|
|
|
|
if (currRecord != null)
|
|
{
|
|
// aggiorno
|
|
await CDService.RegAttDelete(currRecord);
|
|
// registro fatto
|
|
await ItemUpdated.InvokeAsync(true);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indico item selezionato
|
|
/// </summary>
|
|
protected async void DoReset()
|
|
{
|
|
await ItemReset.InvokeAsync(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorno e riporto update
|
|
/// </summary>
|
|
protected async void DoUpdate()
|
|
{
|
|
arrotondaMinuti();
|
|
// aggiorno
|
|
if (currRecord != null)
|
|
{
|
|
// controllo IdxDipendente
|
|
if (currRecord.IdxDipendente == 0)
|
|
{
|
|
currRecord.IdxDipendente = AppMServ.IdxDipendente;
|
|
}
|
|
|
|
// prearo lista inserimento
|
|
List<RegAttivitaModel> data2ins = new List<RegAttivitaModel>();
|
|
|
|
// se inizio/fine stesso giorno processo
|
|
if (currRecord.Fine.Date.Equals(currRecord.Inizio.Date))
|
|
{
|
|
data2ins.Add(currRecord);
|
|
}
|
|
// in caso di eventuale supero della mezzanotte --> chiedo se si vuole split su 2 attività...
|
|
else
|
|
{
|
|
bool doSplit = await JSRuntime.InvokeAsync<bool>("confirm", "L'attività si protrae su più giorni, vuoi suddividere in record per ogni giornata?");
|
|
// chiedo verifica x splittare in N+1 periodi (N = giorni)
|
|
if (doSplit)
|
|
{
|
|
RegAttivitaModel currRA = currRecord.Clone() as RegAttivitaModel;
|
|
// primo record è inizio --> mezzanote
|
|
DateTime lastInizio = currRA.Inizio;
|
|
DateTime lastFine = currRA.Inizio.Date.AddDays(1);
|
|
currRA.Fine = lastFine;
|
|
data2ins.Add(currRA);
|
|
// calcolo i gg
|
|
int numGG = currRecord.Fine.Date.Subtract(currRecord.Inizio.Date).Days;
|
|
// ciclo
|
|
for (int i = 0; i < numGG; i++)
|
|
{
|
|
// splitto... inizio = fine + 1 sec...
|
|
currRA = currRecord.Clone() as RegAttivitaModel;
|
|
currRA.Inizio = lastFine;
|
|
// porto avanti ultima fine...
|
|
lastFine = lastFine.AddDays(1);
|
|
currRA.Fine = currRA.Fine > lastFine ? lastFine : currRA.Fine;
|
|
data2ins.Add(currRA);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
data2ins.Add(currRecord);
|
|
}
|
|
}
|
|
// ciclo x inserire
|
|
foreach (var item in data2ins)
|
|
{
|
|
await CDService.RegAttUpdate(item);
|
|
}
|
|
}
|
|
// resetto clone e record corrente...
|
|
AppMServ.clonedRA = null;
|
|
currRecord = null;
|
|
// registro fatto
|
|
await ItemUpdated.InvokeAsync(true);
|
|
}
|
|
|
|
protected async Task ReloadData(bool resetProj, bool resetFase)
|
|
{
|
|
gruppiList = await CDService.AnagGruppiUser(AppMServ.IdxDipendente);
|
|
var allProj = await CDService.AnagProjAll();
|
|
projList = allProj
|
|
.Where(x => x.Attivo == true && x.Gruppo == gruppoSel)
|
|
.OrderBy(x => x.ClienteNav.RagSociale)
|
|
.ThenBy(x => x.NomeProj)
|
|
.ToList();
|
|
if (resetProj)
|
|
{
|
|
if (projList.Count > 0)
|
|
{
|
|
idxProj = projList[0].IdxProgetto;
|
|
}
|
|
}
|
|
var fasiProj = await CDService.AnagFasiByProj(idxProj);
|
|
if (fasiProj != null)
|
|
{
|
|
fasiList = fasiProj;
|
|
}
|
|
else
|
|
{
|
|
fasiList = new List<AnagFasiModel>();
|
|
}
|
|
if (resetFase)
|
|
{
|
|
// se ho 2+ risultati --> il primo è titolo faccio il secondo
|
|
if (fasiList.Count > 1)
|
|
{
|
|
var currData = fasiList.Skip(1).FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
idxFase = currData.IdxFase;
|
|
}
|
|
}
|
|
// altrimenti primo...
|
|
else
|
|
{
|
|
var currData = fasiList.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
idxFase = currData.IdxFase;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
}
|
|
} |