Пример #1
0
        /// <summary>
        ///   Il metodo accetta in firma il command, e aggiorna i dati relativi alla conferma della partenza
        /// </summary>
        /// <param name="command">il command in ingresso</param>
        /// <returns>ConfermaPartenze</returns>
        public ConfermaPartenze Update(ConfermaPartenzeCommand command)
        {
            var conferma = new ConfermaPartenze();

            _updateRichiesta.UpDate(command.ConfermaPartenze.richiesta);
            var tipologia = _getTipologieByCodice.Get(command.ConfermaPartenze.richiesta.Tipologie)[0];

            foreach (var partenza in command.ConfermaPartenze.Partenze)
            {
                var dataMovintazione = DateTime.UtcNow;

                //_setMovimentazione.Set(partenza.Mezzo.Codice, DateTime.UtcNow, command.ConfermaPartenze.IdRichiesta, tipologia.Codice, tipologia.Descrizione); //TODO IMPLEMENTARE CON GAC
                _setStatoOperativoMezzo.Set(command.ConfermaPartenze.CodiceSede, partenza.Mezzo.Codice, Costanti.MezzoInViaggio, command.ConfermaPartenze.IdRichiesta);

                foreach (var squadra in partenza.Squadre)
                {
                    _setStatoSquadra.SetStato(squadra.Codice, command.ConfermaPartenze.IdRichiesta, Costanti.MezzoInViaggio, command.ConfermaPartenze.CodiceSede);
                }
            }

            conferma.CodiceSede  = command.ConfermaPartenze.CodiceSede;
            conferma.IdRichiesta = command.ConfermaPartenze.IdRichiesta;
            conferma.richiesta   = command.ConfermaPartenze.richiesta;
            return(conferma);
        }
Пример #2
0
        public async Task <IActionResult> Post(ConfermaPartenze conferma)
        {
            conferma.CodiceSede  = Request.Headers["codicesede"];
            conferma.IdOperatore = Request.Headers["IdUtente"];

            var command = new ConfermaPartenzeCommand()
            {
                ConfermaPartenze = conferma
            };

            try
            {
                handler.Handle(command);

                return(Ok());
            }
            catch (Exception ex)
            {
                ex = ex.GetBaseException();

                if (ex.Message.Contains(Costanti.UtenteNonAutorizzato))
                {
                    return(StatusCode(403, new { message = Costanti.UtenteNonAutorizzato }));
                }
                else
                {
                    return(BadRequest(new { message = ex.Message }));
                }
            }
        }
        public async Task SendNotification(ConfermaPartenzeCommand conferma)
        {
            var        mapper = new MapperRichiestaAssistenzaSuSintesi(_mapper);
            const bool notificaChangeState = true;

            var richiesta = conferma.ConfermaPartenze.richiesta;
            var sintesi   = mapper.Map(richiesta);

            sintesi.Motivazione = sintesi.Descrizione;

            var boxRichiesteQuery     = new BoxRichiesteQuery();
            var boxMezziQuery         = new BoxMezziQuery();
            var boxPersonaleQuery     = new BoxPersonaleQuery();
            var sintesiRichiesteQuery = new SintesiRichiesteAssistenzaQuery();
            var sintesiRichiesteAssistenzaMarkerQuery = new SintesiRichiesteAssistenzaMarkerQuery();
            var boxInterventi      = _boxRichiestehandler.Handle(boxRichiesteQuery).BoxRichieste;
            var boxMezzi           = _boxMezzihandler.Handle(boxMezziQuery).BoxMezzi;
            var boxPersonale       = _boxPersonalehandler.Handle(boxPersonaleQuery).BoxPersonale;
            var sintesiRichieste   = _sintesiRichiesteHandler.Handle(sintesiRichiesteQuery).SintesiRichiesta;
            var listaSintesiMarker = _sintesiRichiesteAssistenzaMarkerhandler.Handle(sintesiRichiesteAssistenzaMarkerQuery).SintesiRichiestaMarker;

            conferma.ConfermaPartenze.Chiamata = sintesi;

            await _notificationHubContext.Clients.Group(conferma.ConfermaPartenze.CodiceSede).SendAsync("ModifyAndNotifySuccess", conferma.ConfermaPartenze);

            if (conferma.ConfermaPartenze.IdRichiestaDaSganciare != null)
            {
                conferma.ConfermaPartenze.Chiamata = sintesiRichieste.LastOrDefault(x => x.Codice == conferma.ConfermaPartenze.IdRichiesta);
                await _notificationHubContext.Clients.Group(conferma.ConfermaPartenze.CodiceSede).SendAsync("ModifyAndNotifySuccess", conferma.ConfermaPartenze);

                conferma.ConfermaPartenze.Chiamata = sintesiRichieste.LastOrDefault(x => x.Codice == conferma.ConfermaPartenze.IdRichiestaDaSganciare);
                await _notificationHubContext.Clients.Group(conferma.ConfermaPartenze.CodiceSede).SendAsync("ModifyAndNotifySuccess", conferma.ConfermaPartenze);
            }

            await _notificationHubContext.Clients.Group(conferma.ConfermaPartenze.CodiceSede).SendAsync("ChangeStateSuccess", notificaChangeState);

            await _notificationHubContext.Clients.Group(conferma.ConfermaPartenze.CodiceSede).SendAsync("NotifyGetBoxInterventi", boxInterventi);

            await _notificationHubContext.Clients.Group(conferma.ConfermaPartenze.CodiceSede).SendAsync("NotifyGetBoxMezzi", boxMezzi);

            await _notificationHubContext.Clients.Group(conferma.ConfermaPartenze.CodiceSede).SendAsync("NotifyGetBoxPersonale", boxPersonale);

            await _notificationHubContext.Clients.Group(conferma.ConfermaPartenze.CodiceSede).SendAsync("NotifyGetRichiestaMarker", listaSintesiMarker.LastOrDefault(marker => marker.CodiceRichiesta == sintesi.CodiceRichiesta));
        }
        public async Task <IActionResult> Post(ConfermaPartenze conferma)
        {
            var codiceSede = Request.Headers["codicesede"];

            conferma.CodiceSede = codiceSede;

            var command = new ConfermaPartenzeCommand()
            {
                ConfermaPartenze = conferma,
            };

            try
            {
                handler.Handle(command);

                return(Ok());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
Пример #5
0
        public async Task SendNotification(ConfermaPartenzeCommand conferma)
        {
            //Sedi gerarchicamente superiori alla richiesta che dovanno ricevere la notifica
            var SediDaNotificare = new List <string>();

            if (conferma.Richiesta.CodSOAllertate != null)
            {
                SediDaNotificare = _getGerarchiaToSend.Get(conferma.Richiesta.CodSOCompetente, conferma.Richiesta.CodSOAllertate.ToArray());
            }
            else
            {
                SediDaNotificare = _getGerarchiaToSend.Get(conferma.Richiesta.CodSOCompetente);
            }

            //Sedi dei mezzi in partenza che dovranno ricevere la notifica
            SediDaNotificare.AddRange(conferma.ConfermaPartenze.Partenze.Select(c => c.Mezzo.Distaccamento.Codice));
            SediDaNotificare = SediDaNotificare.Distinct().ToList();

            var listaMezziInServizio = Task.Factory.StartNew(() => _getListaMezzi.Get(SediDaNotificare.ToArray()));
            var sintesi = Task.Factory.StartNew(() => _mapperSintesi.Map(conferma.Richiesta)).ContinueWith(sintesi =>
            {
                sintesi.Result.Competenze          = MapCompetenze(conferma.Richiesta.CodUOCompetenza);
                conferma.ConfermaPartenze.Chiamata = sintesi.Result;
                sintesi.Result.Motivazione         = sintesi.Result.Descrizione;

                return(sintesi.Result);
            });

            Parallel.ForEach(SediDaNotificare, sede =>
            {
                var CodSede = new string[] { sede };

                _notificationHubContext.Clients.Group(sede).SendAsync("ChangeStateSuccess", true);

                Task.Factory.StartNew(() =>
                {
                    var boxRichiesteQuery = new BoxRichiesteQuery()
                    {
                        CodiciSede = new string[] { sede }
                    };
                    var boxInterventi = _boxRichiestehandler.Handle(boxRichiesteQuery).BoxRichieste;
                    _notificationHubContext.Clients.Group(sede).SendAsync("NotifyGetBoxInterventi", boxInterventi);
                });

                Task.Factory.StartNew(() =>
                {
                    var boxMezziQuery = new BoxMezziQuery()
                    {
                        CodiciSede = new string[] { sede }
                    };
                    var boxMezzi = _boxMezzihandler.Handle(boxMezziQuery).BoxMezzi;
                    _notificationHubContext.Clients.Group(sede).SendAsync("NotifyGetBoxMezzi", boxMezzi);
                });

                Task.Factory.StartNew(() =>
                {
                    var boxPersonaleQuery = new BoxPersonaleQuery()
                    {
                        CodiciSede = new string[] { sede }
                    };
                    var boxPersonale = _boxPersonalehandler.Handle(boxPersonaleQuery).BoxPersonale;
                    _notificationHubContext.Clients.Group(sede).SendAsync("NotifyGetBoxPersonale", boxPersonale);
                });

                Task.Factory.StartNew(() =>
                {
                    var sintesiRichiesteAssistenzaMarkerQuery = new SintesiRichiesteAssistenzaMarkerQuery()
                    {
                        CodiciSedi = new string[] { sede }
                    };
                    var listaSintesiMarker = _sintesiRichiesteAssistenzaMarkerhandler.Handle(sintesiRichiesteAssistenzaMarkerQuery).SintesiRichiestaMarker;
                    _notificationHubContext.Clients.Group(sede).SendAsync("NotifyGetRichiestaMarker", listaSintesiMarker.LastOrDefault(marker => marker.CodiceRichiesta == sintesi.Result.CodiceRichiesta));
                });

                Task.Factory.StartNew(() =>
                {
                    foreach (var partenze in conferma.ConfermaPartenze.Partenze)
                    {
                        _notificationHubContext.Clients.Group(sede).SendAsync("NotifyUpdateMezzoInServizio", listaMezziInServizio.Result.Find(x => x.Mezzo.Mezzo.Codice.Equals(partenze.Mezzo.Codice)));
                    }
                });

                conferma.ConfermaPartenze.Chiamata = sintesi.Result;
                _notificationHubContext.Clients.Group(sede).SendAsync("ModifyAndNotifySuccess", conferma.ConfermaPartenze);

                if (conferma.ConfermaPartenze.IdRichiestaDaSganciare != null)
                {
                    Task.Factory.StartNew(() =>
                    {
                        var sintesiSganciata               = _mapperSintesi.Map(conferma.RichiestaDaSganciare);
                        sintesiSganciata.Competenze        = MapCompetenze(conferma.Richiesta.CodUOCompetenza);
                        conferma.ConfermaPartenze.Chiamata = sintesiSganciata;
                        _notificationHubContext.Clients.Group(sede).SendAsync("ModifyAndNotifySuccess", conferma.ConfermaPartenze);
                    });
                }
            });
        }
Пример #6
0
        /// <summary>
        ///   Il metodo accetta in firma il command, e aggiorna i dati relativi alla conferma della partenza
        /// </summary>
        /// <param name="command">il command in ingresso</param>
        /// <returns>ConfermaPartenze</returns>
        public ConfermaPartenze Update(ConfermaPartenzeCommand command)
        {
            var    filepath        = CostantiJson.ListaRichiesteAssistenza;
            var    filePathMezzi   = CostantiJson.Mezzo;
            var    filePathSquadre = CostantiJson.SquadreComposizione;
            string json;
            string jsonMezzi;
            string jsonSquadre;

            using (var r = new StreamReader(filepath))
            {
                json = r.ReadToEnd();
            }

            using (var r = new StreamReader(filePathMezzi))
            {
                jsonMezzi = r.ReadToEnd();
            }

            using (var r = new StreamReader(filePathSquadre))
            {
                jsonSquadre = r.ReadToEnd();
            }

            var richiestaDTO      = new RichiestaAssistenzaDTO();
            var conferma          = new ConfermaPartenze();
            var listaRichieste    = JsonConvert.DeserializeObject <List <RichiestaAssistenzaDTO> >(json);
            var listaMezzi        = JsonConvert.DeserializeObject <List <Mezzo> >(jsonMezzi);
            var listaSquadre      = JsonConvert.DeserializeObject <List <ComposizioneSquadre> >(jsonSquadre);
            var listaRichiesteNew = new List <RichiestaAssistenza>();

            if (listaRichieste != null)
            {
                richiestaDTO = listaRichieste.Find(x => x.Cod == command.ConfermaPartenze.richiesta.Codice);
                listaRichieste.Remove(richiestaDTO);

                foreach (var richiesta in listaRichieste)
                {
                    listaRichiesteNew.Add(MapperDTO.MapRichiestaDTOtoRichiesta(richiesta));
                }

                listaRichiesteNew.Add(command.ConfermaPartenze.richiesta);

                var jsonListaPresente = JsonConvert.SerializeObject(listaRichiesteNew);
                System.IO.File.WriteAllText(CostantiJson.ListaRichiesteAssistenza, jsonListaPresente);
            }
            else
            {
                listaRichiesteNew = new List <RichiestaAssistenza>
                {
                    command.ConfermaPartenze.richiesta
                };

                var jsonNew = JsonConvert.SerializeObject(listaRichiesteNew);
                System.IO.File.WriteAllText(CostantiJson.ListaRichiesteAssistenza, jsonNew);
            }

            foreach (var composizione in command.ConfermaPartenze.richiesta.Partenze)
            {
                foreach (var mezzo in listaMezzi)
                {
                    if (mezzo.Codice != composizione.Partenza.Mezzo.Codice)
                    {
                        continue;
                    }
                    mezzo.Stato       = Costanti.MezzoInViaggio;
                    mezzo.IdRichiesta = command.ConfermaPartenze.IdRichiesta;
                }

                foreach (var composizioneSquadra in listaSquadre)
                {
                    foreach (var squadra in composizione.Partenza.Squadre)
                    {
                        if (composizioneSquadra.Squadra.Id == squadra.Id)
                        {
                            composizioneSquadra.Squadra.Stato = Squadra.StatoSquadra.InViaggio;
                        }
                    }
                }
            }

            var jsonListaMezzi = JsonConvert.SerializeObject(listaMezzi);

            File.WriteAllText(CostantiJson.Mezzo, jsonListaMezzi);

            var jsonListaSquadre = JsonConvert.SerializeObject(listaSquadre);

            File.WriteAllText(CostantiJson.SquadreComposizione, jsonListaSquadre);

            conferma.CodiceSede  = command.ConfermaPartenze.CodiceSede;
            conferma.IdRichiesta = command.ConfermaPartenze.IdRichiesta;
            conferma.richiesta   = command.ConfermaPartenze.richiesta;
            return(conferma);
        }
Пример #7
0
        /// <summary>
        ///   Il metodo accetta in firma il command, e aggiorna i dati relativi alla conferma della partenza
        /// </summary>
        /// <param name="command">il command in ingresso</param>
        /// <returns>ConfermaPartenze</returns>
        public ConfermaPartenze Update(ConfermaPartenzeCommand command)
        {
            var conferma = new ConfermaPartenze();

            _updateRichiesta.UpDate(command.ConfermaPartenze.richiesta);

            var codiceSede = command.ConfermaPartenze.CodiceSede.Split(",", StringSplitOptions.RemoveEmptyEntries)[0];

            foreach (var partenza in command.ConfermaPartenze.Partenze)
            {
                var dataMovintazione = DateTime.UtcNow;

                _setStatoOperativoMezzo.Set(codiceSede, partenza.Mezzo.Codice, partenza.Mezzo.Stato, command.ConfermaPartenze.richiesta.Codice);

                foreach (var squadra in partenza.Squadre)
                {
                    _setStatoSquadra.SetStato(squadra.Codice, command.ConfermaPartenze.IdRichiesta, partenza.Mezzo.Stato, codiceSede, partenza.Mezzo.Codice);
                }

                var dataIntervento = command.Richiesta.ListaEventi.OfType <Telefonata>().FirstOrDefault(p => p.CodiceRichiesta.Equals(command.Richiesta.Codice)).Istante;

                //GAC USCITA/ENTRATA
                if (!partenza.Mezzo.Stato.Equals(Costanti.MezzoInUscita))
                {
                    if (partenza.Mezzo.Stato.Equals(Costanti.MezzoInSede) || partenza.Mezzo.Stato.Equals(Costanti.MezzoRientrato))
                    {
                        var dataRientro = command.Richiesta.ListaEventi.OfType <PartenzaRientrata>().FirstOrDefault(p => p.CodicePartenza.Equals(partenza.Codice)).Istante;
                        _setRientroMezzo.Set(new RientroGAC()
                        {
                            targa            = partenza.Mezzo.Codice.Split('.')[1],
                            tipoMezzo        = partenza.Mezzo.Codice.Split('.')[0],
                            idPartenza       = partenza.Codice.ToString(),
                            numeroIntervento = command.Richiesta.CodRichiesta,
                            dataIntervento   = dataIntervento,
                            dataRientro      = dataRientro,
                            autista          = ""
                        });
                    }
                    else if (partenza.Mezzo.Stato.Equals(Costanti.MezzoInViaggio))
                    {
                        var dataUscita = command.Richiesta.ListaEventi.OfType <ComposizionePartenze>().FirstOrDefault(p => p.Partenza.Codice.Equals(partenza.Codice)).Istante;
                        _setUscitaMezzo.Set(new UscitaGAC()
                        {
                            targa            = partenza.Mezzo.Codice.Split('.')[1],
                            tipoMezzo        = partenza.Mezzo.Codice.Split('.')[0],
                            idPartenza       = partenza.Codice.ToString(),
                            numeroIntervento = command.Richiesta.CodRichiesta,
                            dataIntervento   = dataIntervento,
                            dataUscita       = dataUscita,
                            autista          = "",
                            tipoUscita       = new TipoUscita()
                            {
                                codice      = "",
                                descrizione = "Servizio"
                            },
                            comune = new ComuneGAC()
                            {
                                codice      = "",
                                descrizione = command.Richiesta.Localita.Citta,
                            },
                            provincia = new Models.Classi.Gac.ProvinciaGAC()
                            {
                                codice      = "",
                                descrizione = command.Richiesta.Localita.Provincia
                            },
                            localita    = command.Richiesta.Localita.Citta,
                            latitudine  = command.Richiesta.Localita.Coordinate.Latitudine.ToString(),
                            longitudine = command.Richiesta.Localita.Coordinate.Longitudine.ToString(),
                        });
                    }
                }
            }

            conferma.CodiceSede  = command.ConfermaPartenze.CodiceSede;
            conferma.IdRichiesta = command.ConfermaPartenze.IdRichiesta;
            conferma.richiesta   = command.ConfermaPartenze.richiesta;
            return(conferma);
        }