Subversion Repository Public Repository

2015-DDS-K3003-G04

This repository has no backups
This repository's network speed is throttled to 100KB/sec

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel.DataAnnotations;
using System.Data.Entity;
using System.ComponentModel.DataAnnotations.Schema;
using System.Text.RegularExpressions;


namespace DDS.Logica
{

    public class Usuario
    {

        
        
        public int Id { get; set; }
        [Required]
        public String Password { get; set; } //no tendria que ser privado?
        [Required]
        public String UserName { get; set; }
        public String NombreDePila { get; private set; }
        public String Sexo { get; private set; }
        public DateTime FechaDeNacimiento { get; private set; }
        public String Complexion { get; private set; }
        public double Altura { get; private set; }
        public String Ejercicio { get; private set; }
        [NotMapped]
        public Criterio Criterio { get; private set; }

        public virtual Piramide Piramide { get; set; }
        public int PiramideId { get; set; }

        public virtual HashSet<Ingrediente> Preferencias { get; private set; }
        public virtual HashSet<Restriccion> Restricciones { get; private set; }
        public virtual List<Receta> Recetas { get; private set; }
        public virtual List<Planificacion> Historial { get; private set; }
        public virtual List<Grupo> Grupos { get; private set; }
        public bool esAdministrador
        {
            get { return (this.UserName == "admin" && this.Password == "admin"); } 
            set {} 
        }

        public Usuario()
        {
        }

        public Usuario(UsuarioViewModel datos)
        {
            this.Recetas = new List<Receta>();
            this.Historial = new List<Planificacion>();
            this.Grupos = new List<Grupo>();
            UserName = datos.UserName;
            NombreDePila = datos.NombreDePila;
            Password = datos.Password;
            Sexo = datos.Sexo;
            FechaDeNacimiento = datos.FechaDeNacimiento;
            Complexion = datos.Complexion;
            Altura = datos.Altura;
            Ejercicio = datos.Ejercicio;
            Restricciones = new HashSet<Restriccion>(datos.Restricciones);
            Preferencias = new HashSet<Ingrediente>(datos.Preferencias);
            Criterio = datos.Criterio;
            Piramide = datos.Piramide;

            if (!this.EsValido()) throw new ArgumentException("Usuario Invalido!");
            else Contexto.Usuarios.Add(this);
        }


        public void Modificar(UsuarioViewModel datos)
        {
            if (!datos.EsValido()) throw new ArgumentException("Usuario Invalido!");

            UserName = datos.UserName;
            NombreDePila = datos.NombreDePila;
            Password = datos.Password;
            Sexo = datos.Sexo;
            FechaDeNacimiento = datos.FechaDeNacimiento;
            Complexion = datos.Complexion;
            Altura = datos.Altura;
            Ejercicio = datos.Ejercicio;
            Restricciones = new HashSet<Restriccion>(datos.Restricciones);
            Preferencias = new HashSet<Ingrediente>(datos.Preferencias);
            Criterio = datos.Criterio;
            Piramide = datos.Piramide;

        }

        public UsuarioViewModel GetDatos()
        {
            UsuarioViewModel misDatos = new UsuarioViewModel();

            misDatos.UserName = this.UserName;
            misDatos.NombreDePila = this.NombreDePila;
            misDatos.Password = this.Password;
            misDatos.Sexo = this.Sexo;
            misDatos.FechaDeNacimiento = this.FechaDeNacimiento;
            misDatos.Complexion = this.Complexion;
            misDatos.Altura = this.Altura;
            misDatos.Ejercicio = this.Ejercicio;
            misDatos.Restricciones = new HashSet<Restriccion>(this.Restricciones);
            misDatos.Preferencias = new HashSet<Ingrediente>(this.Preferencias);
            misDatos.Criterio = this.Criterio;
            misDatos.Piramide = this.Piramide;

            return misDatos;
        }

        public bool PasswordCorrecto (String password)
        {
            return (password == this.Password);
        }

        public bool TieneReceta (Receta receta)
        {
            return (this.Recetas.Contains(receta));
        }

        public bool PerteneceAGrupo(Grupo grupo)
        {
            return this.Grupos.Contains(grupo);
        }

        public void UnirseAGrupo(Grupo grupo)
        {
            if (Grupos.Contains(grupo)) throw new ArgumentException("El usuario ya pertenece al grupo");
            else
            {
                Grupos.Add(grupo);
                if (!grupo.ExisteUsuario(this)) grupo.AgregarUsuario(this);
            }
        }

        public void SalirDeGrupo(Grupo grupo)
        {
            if (!Grupos.Contains(grupo)) throw new ArgumentException("El usuario no pertenece al grupo");
            else
            {
                Grupos.Remove(grupo);
                if (grupo.ExisteUsuario(this)) grupo.EliminarUsuario(this);
            }
        }

        public void ReemplazarReceta(Receta recetaAntes, Receta recetaDespues)
        {
            if (!this.Recetas.Contains(recetaAntes)) throw new ArgumentException("La receta no pertenece al Usuario!");

            EliminarReceta(recetaAntes);
            foreach (Grupo grupo in this.Grupos) if (grupo.ExisteReceta(recetaAntes))
            {
                grupo.DejarDeCompartirReceta(recetaAntes);
                grupo.CompartirReceta(recetaDespues);
            }
            AgregarReceta(recetaDespues);
        }



        public void AgregarReceta(Receta recetaNueva)
        {
            if (Recetas.Contains(recetaNueva)) throw new ArgumentException("La receta ya existe");
            this.Recetas.Add(recetaNueva);    
        }



        public void EliminarReceta(Receta recetaParaEliminar)
        {
            if (!this.Recetas.Remove(recetaParaEliminar)) throw new ArgumentException("La receta no pertenece al Usuario!");
            foreach (Grupo grupo in this.Grupos) grupo.DejarDeCompartirReceta(recetaParaEliminar);
        }



        public Planificacion ConsultaPlanificacion(DateTime fecha, TipoDeComida momento)
        {
            return this.Historial.Find(P => P != null && P.FechaHora.Equals(fecha) && P.Comida.Equals(momento));
        }



        public void AgregarPreferencia(Restriccion preferencia)
        {
            if (!(this.Restricciones.Contains(preferencia))) this.Restricciones.Add(preferencia);
        }



        public List<Receta> ListarRecetas()
        {
            HashSet<Receta> RecetasDisponibles = new HashSet<Receta>();
            RecetasDisponibles.UnionWith(Contexto.RecetarioPublico);
            RecetasDisponibles.UnionWith(this.Recetas);
            foreach (Grupo UnGrupo in this.Grupos) RecetasDisponibles.UnionWith(UnGrupo.Recetas);

            return RecetasDisponibles.ToList();
        }

        public List<Receta> ListarRecetasPlanificables()
        {
            return ListarRecetas().Where(Receta => this.PuedeComer(Receta)).ToList();
        }



        public List<Receta> ListarRecetasRecomendadas(TipoDeComida TipoDeComida, DateTime fecha)
        {
            return ListarRecetasPlanificables().Where(receta => receta.TiposDeComidaRecomendados.Contains(TipoDeComida) && receta.EstaEnTemporada(fecha)).ToList();
        }



        private bool PuedeComer(Receta Receta)
        {
            return !this.Restricciones.Any(Preferencia => !Receta.EsAptoPara(Preferencia));
        }



        public bool Planificar(DateTime fechaHora, TipoDeComida momento, Receta receta = null)
        {

            DateTime fechaHoraActual = DateTime.Now;

            TimeSpan ts = fechaHoraActual - fechaHora;

            int diferencia = ts.Days;

            if (diferencia < 7 && diferencia > -7)
            {

                Planificacion PlanificacionAntigua = this.ConsultaPlanificacion(fechaHora, momento);

                if (PlanificacionAntigua != null) if (PlanificacionAntigua.Receta != null)
                {
                    Planificacion unaPlanificacion = this.Historial.Find(P => P.Receta.Equals(PlanificacionAntigua.Receta));
                    if(unaPlanificacion != null) this.Historial.Remove(unaPlanificacion);
                }
                if (new TipoDeComida(fechaHora).Equals(momento))
                {
                    if (receta != null) this.Historial.Add(new Planificacion(fechaHora, receta));
                    else this.Historial.Remove(ConsultaPlanificacion(fechaHora, momento));
                    return true;
                }
                else throw new ArgumentException("Tipo de comida incorrecta para esa hora");
            }
            else throw new ArgumentException("No se puede planificar mas alla de una semana");
            
        }



        public bool EsValido()
        {       
            if (Contexto.Usuarios.Any(usuario => usuario.UserName == this.UserName)) return false;
            if (String.IsNullOrEmpty(UserName) || 
              !(Regex.IsMatch(
                UserName, 
                @"^(?("")("".+?""@)|(([0-9a-zA-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-zA-Z])@))" + 
                @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,6}))$")
                )) return false;
            if (FechaDeNacimiento > DateTime.Now.AddYears(-18) || FechaDeNacimiento < DateTime.Now.AddYears(-200)) return false;
            if (String.IsNullOrWhiteSpace(NombreDePila)) return false;
            return true;         
        }



        public List<Planificacion> ListaPlanificacionesSegunEstacion(String estacion)
        {
            List<Planificacion> listaFiltrada = new List<Planificacion>();
            listaFiltrada = this.Historial.Where(plan => plan.Receta.EstaEnTemporada(new Estacion(estacion)) ).ToList();
            return listaFiltrada;
        }
        public List<Planificacion> ListaPlanificacionesSegunPeriodo(DateTime FechaInicio , DateTime FechaFin )
        {
            if (this.Historial.Count() == 0) throw new ArgumentException("El Usuario no tiene Comidas Planificadas!");
            List<Planificacion> listaPeriodo = new List<Planificacion>();
            listaPeriodo = this.Historial.Where(plan => plan.FechaHora >= FechaInicio &&
                plan.FechaHora <= FechaFin).ToList();
            return listaPeriodo;
        }
        public List<Planificacion> ListaPlanificacionesSegunIngrediente(Ingrediente ingrediente)
        {
            if (this.Historial.TrueForAll(plan => !plan.Receta.Ingredientes.Contains(ingrediente))) 
                throw new ArgumentException("El usuario no tiene comidas programadas con ese ingrediente o no tiene comidas programadas");
             
            List<Planificacion> listaIngrediente = new List<Planificacion>();
            listaIngrediente = this.Historial.Where
                (plan => plan.Receta.Ingredientes.Contains(ingrediente)).ToList();
            return listaIngrediente;
        }
        public List<Planificacion> ListaPlanificacionesCalorias(int caloriasMin, int caloriasMax)
        {
            if (this.Historial.Count() == 0) throw new ArgumentException("El Usuario no tiene Comidas Planificadas!");
            List<Planificacion> listaCalorias = new List<Planificacion>();
            listaCalorias = this.Historial.Where
                (plan => plan.Receta.Calorias >= caloriasMin && plan.Receta.Calorias <= caloriasMax).ToList();
            return listaCalorias;

        }
        public List<Planificacion> ListarPlanificacionesNombreReceta(string NombreReceta)
        {
            if (this.Historial.TrueForAll(plan => !(plan.Receta.Nombre == NombreReceta)))
                throw new ArgumentException("La receta no se utilizó en niguna comida");
            List<Planificacion> listaNombreReceta = new List<Planificacion>();
            listaNombreReceta = this.Historial.Where(plan => plan.Receta.Nombre == NombreReceta).ToList();
            return listaNombreReceta;
        }
        public List<Planificacion> ListarPlanificacionesGrupo(Grupo grupo)
        {
            if (!this.Grupos.Contains(grupo)) 
                throw new ArgumentException("No es un grupo del usuario");
            List<Planificacion> listaGrupo = new List<Planificacion>();
            listaGrupo = this.Historial.Where(plan => grupo.ExisteReceta(plan.Receta)).ToList();
            return listaGrupo;
        }
        public List<Planificacion> ListPlanificacionesPersonaCompartio (Usuario usuario)
        {
            if (this.Historial.TrueForAll(plan => plan.Receta.PerteneceA(usuario) && (usuario.Grupos.Intersect(this.Grupos) != null)))
                throw new ArgumentException("el usuario no pernetece al mismo grupo");
            List<Planificacion> listaPersonaCompartio = new List<Planificacion>();
                //persona que compartio la receta que esta en la planificacion
            listaPersonaCompartio = this.Historial.Where(plan => plan.Receta.PerteneceA(usuario)).ToList();
            return listaPersonaCompartio;
        }
        
        public List<Receta> ListarRecetasNuevas(int cantidad)
        {
            return ListarRecetas().OrderBy(receta => receta.FechaHoraCreada).Take(cantidad).ToList();
        }

        public override bool Equals(object obj)
        {
            var item = obj as Usuario;

            if (item == null)
            {
                return false;
            }
            return this.UserName.Equals(item.UserName);
        }
        public override int GetHashCode()
        {
            return this.UserName.GetHashCode();
        }
    }




    public class UsuarioViewModel
    {
        public String UserName;
        public String Password;
        public string NombreDePila;
        public String Sexo;
        public DateTime FechaDeNacimiento;
        public String Complexion;
        public double Altura;
        public String Ejercicio;
        public HashSet<Restriccion> Restricciones;
        public HashSet<Ingrediente> Preferencias;
        public Criterio Criterio;
        public Piramide Piramide;
        

        public UsuarioViewModel()
        {
            Restricciones = new HashSet<Restriccion>();
            Preferencias = new HashSet<Ingrediente>();
        }

        public bool EsValido()
        {
            //if (String.IsNullOrEmpty(UserName) || !(new EmailAddressAttribute().IsValid(UserName))) return false;
            //if (FechaDeNacimiento > DateTime.Now.AddYears(-18) || FechaDeNacimiento < DateTime.Now.AddYears(-200)) return false;
            //if (String.IsNullOrWhiteSpace(NombreDePila)) return false;
            return true;
        }


    }





}

Commits for 2015-DDS-K3003-G04/trunk/TP.DDS/DDS.Logica/Models/Usuario.cs

Diff revisions: vs.
Revision Author Commited Message
182 Diff Diff softbax picture softbax Mon 12 Oct, 2015 03:07:39 +0000

asquerosidad en los ingredientes!!!

180 Diff Diff jlsoto85 picture jlsoto85 Mon 12 Oct, 2015 02:47:02 +0000
173 Diff Diff jlsoto85 picture jlsoto85 Mon 12 Oct, 2015 00:33:38 +0000
167 Diff Diff lucasmoglia picture lucasmoglia Sun 11 Oct, 2015 15:06:24 +0000

Implementación de code first to database

166 Diff Diff lucasmoglia picture lucasmoglia Tue 29 Sep, 2015 15:25:20 +0000

Implementación de EF

Cambios en UI – Administrador (mock)

161 Diff Diff jlsoto85 picture jlsoto85 Sat 12 Sep, 2015 08:28:40 +0000

creados tests para recomendaciones

160 Diff Diff jlsoto85 picture jlsoto85 Sat 12 Sep, 2015 04:50:03 +0000

Terminado redisenio de tests de tercera entrega

157 Diff Diff jlsoto85 picture jlsoto85 Thu 10 Sep, 2015 18:06:17 +0000

Eliminado GrupoAlimenticio, funcionalidad trasladada a Nivel

154 Diff Diff jlsoto85 picture jlsoto85 Thu 10 Sep, 2015 03:40:45 +0000

Primermos 5 tests de la entrega 3

151 jlsoto85 picture jlsoto85 Wed 09 Sep, 2015 06:58:22 +0000

Terminado el redisenio de los tests de la entrega 3 y arreglado errores