Beispiel #1
0
        internal async static Task InserisciCalendario(Calendario calendario, string IDRisorsaAttivita, string Data, string IDOraInizio, string IDOraFine, string IDEsercente)
        {
            var vRealmDb = await GetRealm();

            RisorsaAttivita risorsaAttivita = vRealmDb.Find <RisorsaAttivita>(IDRisorsaAttivita);
            Esercente       esercente       = vRealmDb.Find <Esercente>(IDEsercente);

            if (risorsaAttivita == null || IDOraFine == null || IDOraInizio == null || Data == null)
            {
                return;
            }

            string[] dtAppo = Data.Split("#");

            DateTime DataOK = new DateTime(Convert.ToInt32(dtAppo[0]), Convert.ToInt32(dtAppo[1]), Convert.ToInt32(dtAppo[2]));

            DataOK = DataOK.AddHours(12);

            var trans = vRealmDb.BeginWrite();

            Calendario md = new Calendario
            {
                RisorsaAttivita = risorsaAttivita,
                Esercente       = esercente,
                Data            = DataOK,
                OraInizio       = Convert.ToInt32(IDOraInizio),
                OraFine         = Convert.ToInt32(IDOraFine),
                Capienza        = calendario.Capienza
            };

            vRealmDb.Add(md);

            trans.Commit();
        }
Beispiel #2
0
        internal async static Task AggiornaCalendario(Calendario calendario, string IDRisorsaAttivita, string Data, string IDOraInizio, string IDOraFine, string IDEsercente, string IDCalendario)
        {
            var vRealmDb = await GetRealm();

            RisorsaAttivita risorsaAttivita = vRealmDb.Find <RisorsaAttivita>(IDRisorsaAttivita);
            Esercente       esercente       = vRealmDb.Find <Esercente>(IDEsercente);
            Calendario      cMod            = vRealmDb.Find <Calendario>(IDCalendario);


            if (risorsaAttivita == null || IDOraFine == null || IDOraInizio == null || Data == null)
            {
                return;
            }

            string[] dtAppo = Data.Split("#");

            DateTime DataOK = new DateTime(Convert.ToInt32(dtAppo[0]), Convert.ToInt32(dtAppo[1]), Convert.ToInt32(dtAppo[2]));

            DataOK = DataOK.AddHours(12);

            var trans = vRealmDb.BeginWrite();

            cMod.RisorsaAttivita = risorsaAttivita;
            cMod.Esercente       = esercente;
            cMod.Data            = DataOK;
            cMod.OraInizio       = Convert.ToInt32(IDOraInizio);
            cMod.OraFine         = Convert.ToInt32(IDOraFine);
            cMod.Capienza        = calendario.Capienza;

            trans.Commit();
        }
Beispiel #3
0
        internal static async Task <Esercente> AggiornaEsercente(Esercente esercente, string IDCategoria, string IDOraInizio, string IDOraFine, string IDSlot)
        {
            var vRealmDb = await GetRealm();

            Esercente eseMod    = vRealmDb.Find <Esercente>(esercente.ID);
            Categoria categoria = vRealmDb.Find <Categoria>(IDCategoria);

            var trans = vRealmDb.BeginWrite();

            eseMod.RagioneSociale  = esercente.RagioneSociale;
            eseMod.Indirizzo       = esercente.Indirizzo;
            eseMod.CAP             = esercente.CAP;
            eseMod.Comune          = esercente.Comune;
            eseMod.Provincia       = esercente.Provincia;
            eseMod.Telefono        = esercente.Telefono;
            eseMod.Sitoweb         = esercente.Sitoweb;
            eseMod.RagioneSocialeF = esercente.RagioneSocialeF;
            eseMod.IndirizzoF      = esercente.IndirizzoF;
            eseMod.CAPF            = esercente.CAPF;
            eseMod.ComuneF         = esercente.ComuneF;
            eseMod.ProvinciaF      = esercente.ProvinciaF;
            eseMod.PEC             = esercente.PEC;
            eseMod.SDI             = esercente.SDI;
            eseMod.Mail            = esercente.Mail;
            eseMod.Categoria       = categoria;
            eseMod.OraInizio       = Convert.ToInt32(IDOraInizio);
            eseMod.OraFine         = Convert.ToInt32(IDOraFine);
            eseMod.MinutiSlot      = Convert.ToInt32(IDSlot);

            trans.Commit();

            return(esercente);
        }
Beispiel #4
0
        internal static async Task <Esercente> Esercente(string ID)
        {
            var vRealmDb = await GetRealm();

            Esercente esercente = vRealmDb.Find <Esercente>(ID);

            return(esercente);
        }
Beispiel #5
0
        internal async static Task InserisciPianificazione(Pianificazione pianificazione, string IDRisorsaAttivita, int IDGiorno, string IDOraInizio, string IDOraFine, string IDEsercente)
        {
            var vRealmDb = await GetRealm();

            RisorsaAttivita risorsaAttivita = vRealmDb.Find <RisorsaAttivita>(IDRisorsaAttivita);
            Giorno          giorno          = vRealmDb.Find <Giorno>(IDGiorno);
            Esercente       esercente       = vRealmDb.Find <Esercente>(IDEsercente);

            if (risorsaAttivita == null || IDOraFine == null || IDOraInizio == null)
            {
                return;
            }

            var trans = vRealmDb.BeginWrite();

            if (IDGiorno == 7)
            {
                for (int i = 0; i <= 6; i++)
                {
                    giorno = vRealmDb.Find <Giorno>(i);
                    Pianificazione md = new Pianificazione
                    {
                        RisorsaAttivita = risorsaAttivita,
                        Esercente       = esercente,
                        Giorno          = giorno,
                        OraInizio       = Convert.ToInt32(IDOraInizio),
                        OraFine         = Convert.ToInt32(IDOraFine),
                        Capienza        = pianificazione.Capienza
                    };
                    vRealmDb.Add(md);
                }
            }
            else
            {
                Pianificazione md = new Pianificazione
                {
                    RisorsaAttivita = risorsaAttivita,
                    Esercente       = esercente,
                    Giorno          = giorno,
                    OraInizio       = Convert.ToInt32(IDOraInizio),
                    OraFine         = Convert.ToInt32(IDOraFine),
                    Capienza        = pianificazione.Capienza
                };

                vRealmDb.Add(md);
            }

            trans.Commit();
        }
Beispiel #6
0
        internal async static Task <IEnumerable <Risorsa> > ListaRisorse(Esercente esercente)
        {
            var vRealmDb = await GetRealm();

            List <Risorsa> listaOutput = new List <Risorsa>();

            IEnumerable <Risorsa> lista = vRealmDb.All <Risorsa>().Where(ss => ss.Esercente == esercente);

            foreach (Risorsa item in lista)
            {
                listaOutput.Add(item);
            }

            return(listaOutput);
        }
Beispiel #7
0
        internal async static Task <IEnumerable <Attivita> > ListaAttivita(Esercente esercente)
        {
            var vRealmDb = await GetRealm();

            List <Attivita> listaOutput = new List <Attivita>();

            IEnumerable <Attivita> lista = vRealmDb.All <Attivita>().Where(ss => ss.Esercente == esercente).OrderBy(a => a.Descrizione);

            foreach (Attivita item in lista)
            {
                listaOutput.Add(item);
            }

            return(listaOutput);
        }
Beispiel #8
0
        internal async static Task CreaCalendario(string IDesercente, int IDSettimana, int Anno)
        {
            var vRealmDb = await GetRealm();

            //crea il calenadio aziendale per la settimana indicata basandosi sulla Pianificazione dell'Esercente

            Esercente esercente = vRealmDb.Find <Esercente>(IDesercente);

            DateTime dtPrimoGiornoSettimana  = Utils.Utils.PrimoGiornoSettimana(Anno, IDSettimana);
            DateTime dtUltimoGiornoSettimana = dtPrimoGiornoSettimana.AddDays(6);

            IEnumerable <Pianificazione> pianificazione = await ListaPianificazioni(esercente, -1, "-1", "-1", true, false, false);

            var trans = vRealmDb.BeginWrite();

            if (pianificazione.Count() > 0)   //cancelliamo tutto solo se la pianificazione ha almeno un record da inserire
            {
                //cancellazione prenotazioni
                var listaC = vRealmDb.All <Calendario>().Where(ss => ss.Data <= dtUltimoGiornoSettimana && ss.Data >= dtPrimoGiornoSettimana && ss.Esercente == esercente);
                foreach (Calendario cc in listaC)
                {
                    var listaP = vRealmDb.All <Prenotazione>().Where(ss => ss.Calendario == cc);
                    vRealmDb.RemoveRange <Prenotazione>(listaP);
                }

                //cancellazione calendario
                vRealmDb.RemoveRange <Calendario>(listaC);
            }

            //inserimento nuovi elementi nel Calnedario
            foreach (Pianificazione ss in pianificazione)
            {
                Calendario md = new Calendario
                {
                    RisorsaAttivita = ss.RisorsaAttivita,
                    Esercente       = esercente,
                    OraInizio       = ss.OraInizio,
                    OraFine         = ss.OraFine,
                    Pianificazione  = ss,
                    Capienza        = ss.Capienza,
                    Data            = dtPrimoGiornoSettimana.AddDays(ss.Giorno.ID - 1).AddHours(12)
                };
                vRealmDb.Add(md);
            }

            trans.Commit();
        }
Beispiel #9
0
        internal async static Task InserisciAttivita(string IDesercente, Attivita attivita)
        {
            var vRealmDb = await GetRealm();

            Esercente esercente = vRealmDb.Find <Esercente>(IDesercente);

            var trans = vRealmDb.BeginWrite();

            Attivita md = new Attivita
            {
                Esercente   = esercente,
                Descrizione = attivita.Descrizione
            };

            vRealmDb.Add(md);

            trans.Commit();
        }
Beispiel #10
0
        internal async static Task InserisciRisorsa(string IDesercente, Risorsa risorsa)
        {
            var vRealmDb = await GetRealm();

            Esercente esercente = vRealmDb.Find <Esercente>(IDesercente);

            var trans = vRealmDb.BeginWrite();

            Risorsa md = new Risorsa
            {
                Esercente   = esercente,
                Descrizione = risorsa.Descrizione,
                Capienza    = risorsa.Capienza
            };

            vRealmDb.Add(md);

            trans.Commit();
        }
Beispiel #11
0
        internal async static Task <IEnumerable <Calendario> > ListaCalendari(Esercente esercente, DateTime dtPrimoGiorno, string IDRA)
        {
            var vRealmDb = await GetRealm();

            DateTime dtUltimoGiorno        = dtPrimoGiorno.AddDays(7);
            IEnumerable <Calendario> lista = null;

            if (IDRA == "000" || IDRA == "-1")
            {
                lista = vRealmDb.All <Calendario>().Where(ss => ss.Data < dtUltimoGiorno && ss.Data >= dtPrimoGiorno && ss.Esercente == esercente).OrderBy(ss => ss.Data).ThenBy(ss => ss.OraInizio);
            }
            else
            {
                RisorsaAttivita ra = vRealmDb.Find <RisorsaAttivita>(IDRA);
                lista = vRealmDb.All <Calendario>().Where(ss => ss.Data < dtUltimoGiorno && ss.Data >= dtPrimoGiorno && ss.Esercente == esercente && ss.RisorsaAttivita == ra).OrderBy(ss => ss.Data).ThenBy(ss => ss.OraInizio);
            }

            return(lista);
        }
Beispiel #12
0
        internal async static Task InserisciPrenotazione(string IDesercente, string IDCalendario, string IDUtente, string Nota)
        {
            var vRealmDb = await GetRealm();

            Esercente  esercente  = vRealmDb.Find <Esercente>(IDesercente);
            Calendario calendario = vRealmDb.Find <Calendario>(IDCalendario);
            Utente     utente     = vRealmDb.Find <Utente>(IDUtente);

            var trans = vRealmDb.BeginWrite();

            Prenotazione md = new Prenotazione
            {
                Esercente  = esercente,
                Calendario = calendario,
                Utente     = utente,
                Nota       = Nota
            };

            vRealmDb.Add(md);

            trans.Commit();
        }
Beispiel #13
0
        internal async static Task InserisciRisorsaAttivita(string IDesercente, RisorsaAttivita risorsaAttivita, string IDAttivita, string IDRisorsa)
        {
            var vRealmDb = await GetRealm();

            Esercente esercente = vRealmDb.Find <Esercente>(IDesercente);
            Attivita  attivita  = vRealmDb.Find <Attivita>(IDAttivita);
            Risorsa   risorsa   = vRealmDb.Find <Risorsa>(IDRisorsa);

            var trans = vRealmDb.BeginWrite();

            RisorsaAttivita md = new RisorsaAttivita
            {
                Esercente = esercente,
                Attivita  = attivita,
                Risorsa   = risorsa,
                Capienza  = risorsaAttivita.Capienza
            };

            vRealmDb.Add(md);

            trans.Commit();
        }
Beispiel #14
0
        internal static async Task <Pianificazione> AggiornaPianificazione(Pianificazione pianificazione, string IDRisorsaAttivita, int IDGiorno, string IDOraInizio, string IDOraFine, string IDEsercente)
        {
            var vRealmDb = await GetRealm();

            Pianificazione  pMod            = vRealmDb.Find <Pianificazione>(pianificazione.ID);
            Giorno          giorno          = vRealmDb.Find <Giorno>(IDGiorno);
            Esercente       esercente       = vRealmDb.Find <Esercente>(IDEsercente);
            RisorsaAttivita risorsaAttivita = vRealmDb.Find <RisorsaAttivita>(IDRisorsaAttivita);


            var trans = vRealmDb.BeginWrite();

            pMod.RisorsaAttivita = risorsaAttivita;
            pMod.Esercente       = esercente;
            pMod.Giorno          = giorno;
            pMod.OraInizio       = Convert.ToInt32(IDOraInizio);
            pMod.OraFine         = Convert.ToInt32(IDOraFine);
            pMod.Capienza        = pianificazione.Capienza;

            trans.Commit();

            return(pianificazione);
        }
Beispiel #15
0
        internal async static Task <IEnumerable <Pianificazione> > ListaPianificazioni(Esercente esercente, int IDGiorno, string IDAttivita, string IDRisorsa, bool IsSortGiorno, bool IsSortAttivita, bool IsSortRisorsa)
        {
            var vRealmDb = await GetRealm();

            bool bAtt = false;
            bool bRis = false;

            IEnumerable <RisorsaAttivita> risorsaAttivita = null;

            List <Pianificazione> listaOutput = new List <Pianificazione>();

            IEnumerable <Pianificazione> lista = vRealmDb.All <Pianificazione>().Where(ss => ss.Esercente == esercente);

            Attivita attivita = vRealmDb.All <Attivita>().First();

            if (IDGiorno != -1 && IDGiorno != 7)
            {
                Giorno giorno = vRealmDb.Find <Giorno>(IDGiorno);
                lista = vRealmDb.All <Pianificazione>().Where(ss => ss.Esercente == esercente && ss.Giorno == giorno);
            }

            if (IDAttivita != "-1")
            {
                attivita        = vRealmDb.Find <Attivita>(IDAttivita);
                risorsaAttivita = vRealmDb.All <RisorsaAttivita>().Where(ss => ss.Attivita == attivita);
                bAtt            = true;
            }

            if (IDRisorsa != "-1")
            {
                Risorsa risorsa = vRealmDb.Find <Risorsa>(IDRisorsa);
                if (bAtt)
                {
                    risorsaAttivita = vRealmDb.All <RisorsaAttivita>().Where(ss => ss.Risorsa == risorsa && ss.Attivita == attivita);
                }
                else
                {
                    risorsaAttivita = vRealmDb.All <RisorsaAttivita>().Where(ss => ss.Risorsa == risorsa);
                }

                bRis = true;
            }

            foreach (Pianificazione item in lista)
            {
                if (bAtt || bRis)
                {
                    foreach (RisorsaAttivita ra in risorsaAttivita)
                    {
                        if (item.RisorsaAttivita.ID == ra.ID)
                        {
                            listaOutput.Add(item);
                        }
                    }
                }
                else
                {
                    listaOutput.Add(item);
                }
            }

            lista = listaOutput;

            if (IsSortGiorno)
            {
                lista = lista.OrderBy(a => a.Giorno.Ordine).ThenBy(a => a.OraInizio);
            }
            if (IsSortAttivita)
            {
                lista = lista.OrderBy(a => a.RisorsaAttivita.Attivita.Descrizione).ThenBy(a => a.Giorno.Ordine).ThenBy(a => a.OraInizio);
            }
            if (IsSortRisorsa)
            {
                lista = lista.OrderBy(a => a.RisorsaAttivita.Risorsa.Descrizione).ThenBy(a => a.Giorno.Ordine).ThenBy(a => a.OraInizio);
            }

            return(lista);
        }