public HttpResponseMessage getSeguidores(int idUser)//idUser es el seguido
{
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(idUser))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe tal usuario, id: {idUser}"));
}
using (var db = new DBContextModel())
{
List <userModel> usuarios = db.seguidores.Where(o => o.id_seguido == idUser)
.Include(o => o.users).Select(
b => new userModel
{
apellido = b.users.apellido,
descripcion = b.users.descripcion,
email = b.users.email,
id_user = b.users.id_user,
isVendor = b.users.isVendor,
nombre = b.users.nombre,
pass = "******",
puntaje = b.users.puntaje,
username = b.users.username,
img = b.users.img,
puesto_name = b.users.puesto_name,
isActive = b.users.isActive,
dui = b.users.dui,
isDeleted = b.users.isDeleted,
num_telefono = b.users.num_telefono,
xlat = b.users.xlat,
ylon = b.users.ylon
}
).ToList();
return(Request.CreateResponse(HttpStatusCode.OK, usuarios));
}
}
public HttpResponseMessage GetPublicacionesALL(int idUser)//id del usuario
{
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(idUser))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe tal usuario, id: {idUser}"));
}
var varPublicaciones = db.publicaciones
.Include(s => s.users)
.Include(s => s.like_post)
.Include(s => s.comentarios)
.Where(s => s.isDeleted == false && s.users.isDeleted == false)
.Select(b =>
new ResponsePublicacionFeed
{
publicacion = new publicacionesModel
{
descripcion = b.descripcion,
fecha_actualizacion = b.fecha_actualizacion,
fecha_creacion = b.fecha_creacion,
id_post = b.id_post,
id_user = b.id_user,
img = b.img,
isImg = b.isImg,
isDeleted = b.isDeleted
},
UsuarioCreator = new DLL.Models.userModel()
{
apellido = b.users.apellido,
descripcion = b.users.descripcion,
email = b.users.email,
id_user = b.users.id_user,
isVendor = b.users.isVendor,
nombre = b.users.nombre,
pass = "******",
puntaje = b.users.puntaje,
username = b.users.username,
img = b.users.img,
puesto_name = b.users.puesto_name,
isActive = b.users.isActive,
dui = b.users.dui,
isDeleted = b.users.isDeleted,
num_telefono = b.users.num_telefono,
xlat = b.users.xlat,
ylon = b.users.ylon
},
cantComentarios = b.comentarios.Where(c => c.users.isDeleted == false && c.isDeleted == false).ToList().Count,
cantLikes = b.like_post.Where(l => l.users.isDeleted == false).ToList().Count,
IsLiked = b.like_post.FirstOrDefault(l => l.users.id_user == idUser) == default(like_post) ? false : true,
IsSavedPost = b.publicacion_guardada.FirstOrDefault(p => p.id_user == idUser) == default(publicacion_guardada) ? false : true
}
)
.OrderByDescending(o => o.publicacion.fecha_creacion)
.ToList();
return(Request.CreateResponse(HttpStatusCode.OK, varPublicaciones));
}
/// <summary>
/// Recibe un objeto como paramentro y posteriormente intenta almacenarlo en la base de datos
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public async Task <HttpResponseMessage> Post(seguidores item)
{
if (item == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"El seguidor no puede estar sin datos"));
}
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(item.id_seguido))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"No existe el usuario seguido {item.id_seguido}"));
}
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(item.seguidor_id))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"No existe el seguidor {item.seguidor_id}"));
}
if (item.id_seguido == item.seguidor_id)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"No puedes seguirte a ti mismo"));
}
using (var db = new DBContextModel())
{
var seguidorDatos = db.seguidores
.FirstOrDefault(s => s.id_seguido == item.id_seguido && s.seguidor_id == item.seguidor_id);
if (seguidorDatos == default(seguidores))
{
item.accepted = true;
item.fecha = DateTime.Now;
if (r.Post(item))
{
//TODO Push Seguido
var usuarioSeguido = db.users.Find(item.id_seguido);
var usuarioSEGUIDOR = db.users.Find(item.seguidor_id);
var receiptInstallID = new Dictionary <string, string>();
try
{
receiptInstallID.Add(usuarioSeguido.Phone_OS, usuarioSeguido.Device_id);
}
catch (Exception) { /**No todos los usuarios tienen telefono asociado **/ }
AppCenterPush appCenterPush = new AppCenterPush(receiptInstallID);
await appCenterPush.Notify("Seguidor nuevo",
$"{usuarioSEGUIDOR.username} ahora te sigue",
"Ve a darle una revisada a su perfil",
new Dictionary <string, string>() {
{ DLL.PushConstantes.gotoPage, DLL.PushConstantes.goto_profile },
{ DLL.PushConstantes.id_user, item.seguidor_id.ToString() }
});
return(Request.CreateResponse(HttpStatusCode.Created, "seguidor guardado correctamente"));
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.OK, "Ya sigues a este usuario, actualiza la página en la que te encuentras"));
}
}
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No es posible guardar los datos del seguidor"));
}
public async Task <HttpResponseMessage> Post(comentarios item)
{
if (item == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"El comentario no puede estar sin datos"));
}
//Valido si existe la publicacion, si no se manda el valor, por defecto es CERO
if (!ValidandoSiExistenDatosRelacionados.ExistsPublicacion(item.id_post))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No existe dicha publicación"));
}
//valido si existe el user que comenta
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(item.id_user))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No existe el usuario"));
}
item.fecha_creacion = DateTime.Now;
item.isDeleted = false;
if (r.Post(item))
{
//TODO PUSH for comment
using (var db = new DBContextModel())
{
users creatorPost = db.publicaciones.SingleOrDefault(u => u.id_post == item.id_post).users;
var receiptInstallID = new Dictionary <string, string>
{
{ creatorPost.Phone_OS, creatorPost.Device_id }
};
AppCenterPush appCenterPush = new AppCenterPush(receiptInstallID);
users CommenterPost = db.users.SingleOrDefault(u => u.id_user == item.id_user);
await appCenterPush.Notify("comentarios",
$"{CommenterPost.nombre} comentó tu publicación",
item.contenido,
new Dictionary <string, string>() {
{ DLL.PushConstantes.gotoPage, DLL.PushConstantes.goto_post },
{ DLL.PushConstantes.id_post, item.id_post.ToString() },
{ DLL.PushConstantes.id_user, creatorPost.id_user.ToString() }
});
}
return(Request.CreateResponse(HttpStatusCode.Created, item));
}
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "No es posible guardar los datos del comentario"));
}
public HttpResponseMessage GetLikesbyIDPost(int idPost)
{
//Validando si existe el post
if (idPost == 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No se recibio ID de la publicación"));
}
if (!ValidandoSiExistenDatosRelacionados.ExistsPublicacion(idPost))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No existe dicha publicación"));
}
using (var db = new DBContextModel())
{
var usuarios = db.like_post
.Include(p => p.users)
.Where(p => p.id_post == idPost && p.users.isDeleted == false)
.ToList();
var usuariosLike = new DLL.ResponseModels.ResponseLikes()
{
id_PostoComentario = idPost,
usuarios = usuarios.Select(b =>
new DLL.Models.userModel()
{
apellido = b.users.apellido,
descripcion = b.users.descripcion,
email = b.users.email,
id_user = b.users.id_user,
isVendor = b.users.isVendor,
nombre = b.users.nombre,
pass = "******",
puntaje = b.users.puntaje,
username = b.users.username,
img = b.users.img,
puesto_name = b.users.puesto_name,
isActive = b.users.isActive,
dui = b.users.dui,
isDeleted = b.users.isDeleted,
num_telefono = b.users.num_telefono,
xlat = b.users.xlat,
ylon = b.users.ylon
}
).ToList()
};
return(Request.CreateResponse(HttpStatusCode.OK, usuariosLike));
}
}
public HttpResponseMessage GetLikesbyIDComentario(int id)
{
if (!ValidandoSiExistenDatosRelacionados.ExistsComment(id))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe tal comentario, id: {id}"));
}
using (var db = new DBContextModel())
{
var usuarios = db.like_comentario
.Include(p => p.users)
.Where(p => p.id_comentario == id && p.users.isDeleted == false).ToList();
var usuariosLike = new DLL.ResponseModels.ResponseLikes()
{
id_PostoComentario = id,
usuarios = usuarios.Select(b =>
new DLL.Models.userModel()
{
apellido = b.users.apellido,
descripcion = b.users.descripcion,
email = b.users.email,
id_user = b.users.id_user,
isVendor = b.users.isVendor,
nombre = b.users.nombre,
pass = "******",
puntaje = b.users.puntaje,
username = b.users.username,
img = b.users.img,
puesto_name = b.users.puesto_name,
isActive = b.users.isActive,
dui = b.users.dui,
isDeleted = b.users.isDeleted,
num_telefono = b.users.num_telefono,
xlat = b.users.xlat,
ylon = b.users.ylon
}
).ToList()
};
return(Request.CreateResponse(HttpStatusCode.OK, usuariosLike));
}
}
public HttpResponseMessage GetPublicacionesFeed(int idUser)//id del usuario
{
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(idUser))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe tal usuario, id: {idUser}"));
}
var varPublicaciones = db.seguidores
.Include(o => o.users1)
.Include(o => o.users1.publicaciones)
.Where(u => u.seguidor_id == idUser) //Yo y de ahi me voy a mis seguidos
.Select(
seg =>
seg.users1.publicaciones
.Where(u => u.users.isDeleted == false && u.isDeleted == false)
.Select(b =>
new ResponsePublicacionFeed
{
//Corregir aca poque debe de ser una lista al final
publicacion = new publicacionesModel
{
descripcion = b.descripcion,
fecha_actualizacion = b.fecha_actualizacion,
fecha_creacion = b.fecha_creacion,
id_post = b.id_post,
id_user = b.id_user,
img = b.img,
isImg = b.isImg,
isDeleted = b.isDeleted
},
UsuarioCreator = new DLL.Models.userModel()
{
apellido = b.users.apellido,
descripcion = b.users.descripcion,
email = b.users.email,
id_user = b.users.id_user,
isVendor = b.users.isVendor,
nombre = b.users.nombre,
pass = "******",
puntaje = b.users.puntaje,
username = b.users.username,
img = b.users.img,
puesto_name = b.users.puesto_name,
isActive = b.users.isActive,
dui = b.users.dui,
isDeleted = b.users.isDeleted,
num_telefono = b.users.num_telefono,
xlat = b.users.xlat,
ylon = b.users.ylon
},
cantComentarios = b.comentarios.Where(c => c.users.isDeleted == false && c.isDeleted == false).ToList().Count,
cantLikes = b.like_post.Where(l => l.users.isDeleted == false).ToList().Count,
IsLiked = b.like_post.FirstOrDefault(l => l.users.id_user == idUser) == default(like_post) ? false : true,
IsSavedPost = b.publicacion_guardada.FirstOrDefault(p => p.id_user == idUser) == default(publicacion_guardada) ? false : true
})
.OrderByDescending(p => p.publicacion.fecha_creacion)
.ToList()
).ToList();
List <ResponsePublicacionFeed> publicacionesOrdenadas = new List <ResponsePublicacionFeed>();
foreach (var publicacionesUsuario in varPublicaciones)
{
foreach (var publicacion in publicacionesUsuario)
{
publicacionesOrdenadas.Add(publicacion);
}
}
publicacionesOrdenadas.OrderByDescending(p => p.publicacion.fecha_creacion);
return(Request.CreateResponse(HttpStatusCode.OK, publicacionesOrdenadas));
}
public async System.Threading.Tasks.Task <HttpResponseMessage> Post(publicaciones item)
{
item.isDeleted = false;
if (item == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"La publicación no puede estar sin datos"));
}
//Publicacion sin imagen o texto
if (item.img == null && string.IsNullOrEmpty(item.descripcion))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, $"La publicación no puede estar sin datos"));
}
//valido si existe el user que publicó
if (item.id_user == 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No se recibio ID del usuario"));
}
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(item.id_user))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "No existe el usuario"));
}
item.fecha_creacion = DateTime.Now;
item.fecha_actualizacion = null;
item.isDeleted = false;
//Intenta el post
if (r.Post(item))
{
//TODO PUSH for comment
using (var db = new DBContextModel())
{
var seguidoresUsuario = db.users.SingleOrDefault(u => u.id_user == item.id_user)
.seguidores1.ToList();
var receiptInstallID = new Dictionary <string, string>();
foreach (var seguidor in seguidoresUsuario)
{
try
{
receiptInstallID.Add(seguidor.users.Phone_OS, seguidor.users.Device_id);
}
catch (Exception) { /**No todos los usuarios tienen telefono asociado **/ }
}
AppCenterPush appCenterPush = new AppCenterPush(receiptInstallID);
users CommenterPost = db.users.SingleOrDefault(u => u.id_user == item.id_user);
await appCenterPush.Notify("publicaciones",
$"{seguidoresUsuario[0].users1.puesto_name} hizo una nueva publicación",
item.descripcion,
new Dictionary <string, string>() {
{ DLL.PushConstantes.gotoPage, DLL.PushConstantes.goto_post },
{ DLL.PushConstantes.id_user, item.id_user.ToString() },
{ DLL.PushConstantes.id_post, item.id_post.ToString() }
});
}
return(Request.CreateResponse(HttpStatusCode.Created, item));
}
//Culpa del server xd
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "No es posible guardar los datos de la publicación"));
}
public HttpResponseMessage Getpublicacion(int idPost, int idUser)//id del usuario
{
if (!ValidandoSiExistenDatosRelacionados.ExistsPublicacion(idPost))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe tal publicación, id: {idPost}"));
}
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(idUser))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe tal usuario, id: {idUser}"));
}
var publicacionAllData = db.publicaciones
.Where(o => o.id_post == idPost)
.Include(o => o.users)
.Include(o => o.like_post)
.Include(o => o.comentarios)
.ToList();
ResponsePublicacion publicacion = new ResponsePublicacion();
ResponsePublicacionFeed publicacionContent = publicacionAllData
.Select(b =>
new ResponsePublicacionFeed()
{
publicacion = new publicacionesModel
{
descripcion = b.descripcion,
fecha_actualizacion = b.fecha_actualizacion,
fecha_creacion = b.fecha_creacion,
id_post = b.id_post,
id_user = b.id_user,
img = b.img,
isImg = b.isImg,
isDeleted = b.isDeleted
},
UsuarioCreator = new userModel()
{
apellido = b.users.apellido,
descripcion = b.users.descripcion,
email = b.users.email,
id_user = b.users.id_user,
isVendor = b.users.isVendor,
nombre = b.users.nombre,
pass = "******",
puntaje = b.users.puntaje,
username = b.users.username,
img = b.users.img,
puesto_name = b.users.puesto_name,
isActive = b.users.isActive,
dui = b.users.dui,
isDeleted = b.users.isDeleted,
num_telefono = b.users.num_telefono,
xlat = b.users.xlat,
ylon = b.users.ylon
},
cantLikes = b.like_post.Where(l => l.users.isDeleted == false).ToList().Count,
cantComentarios = b.comentarios.Where(c => c.isDeleted == false && c.users.isDeleted == false).ToList().Count,
IsLiked = b.like_post.FirstOrDefault(l => l.users.id_user == idUser) == default(like_post) ? false:true,
IsSavedPost = b.publicacion_guardada.FirstOrDefault(l => l.users.id_user == idUser) == default(publicacion_guardada) ? false : true
}
).ToList().First();
List <ResponseComentarios> comentariosPost = db.comentarios
.Where(c => c.id_post == idPost && c.isDeleted == false && c.users.isDeleted == false)
.Include(o => o.users)
.Include(o => o.like_comentario)
.Select(c =>
new ResponseComentarios()
{
CantLikes = c.like_comentario.Where(l => l.users.isDeleted == false).ToList().Count,
isLiked = c.like_comentario.FirstOrDefault(l => l.id_user == idUser) == default(like_comentario) ? false : true,
comentario = new comentariosModel()
{
contenido = c.contenido,
fecha_creacion = c.fecha_creacion,
id_comentario = c.id_comentario,
id_post = c.id_post,
id_user = c.id_user,
isDeleted = c.isDeleted
},
usuario = new userModel()
{
apellido = c.users.apellido,
img = c.users.img,
isActive = c.users.isActive,
email = c.users.email,
dui = c.users.dui,
descripcion = c.users.descripcion,
id_user = c.users.id_user,
isVendor = c.users.isVendor,
nombre = c.users.nombre,
pass = "******",
puntaje = c.users.puntaje,
username = c.users.username,
puesto_name = c.users.puesto_name,
isDeleted = c.users.isDeleted,
num_telefono = c.users.num_telefono,
xlat = c.users.xlat,
ylon = c.users.ylon
}
}
).OrderByDescending(f => f.comentario.fecha_creacion)
.ToList();
publicacion.publicacion = publicacionContent;
publicacion.comentarios = comentariosPost;
//if (lpublicaciones == null || lpublicaciones == default(ResponsePublicacion))
//{
// return Request.CreateResponse(HttpStatusCode.NoContent, "No hay publicaciones");
//}
return(Request.CreateResponse(HttpStatusCode.OK, publicacion));
}
public HttpResponseMessage userprofile(int idUser)//Cuando un usuario ve su propio perfil
{
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(idUser))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe tal usuario, id: {idUser}"));
}
using (var db = new DBContextModel())
{
var varUserProfile = db.users
.Include(s => s.publicaciones)
.Include(s => s.like_post)
.Include(s => s.seguidores)
.Include(s => s.seguidores1)
.Include(s => s.publicacion_guardada)
.Where(u => u.id_user == idUser)
.Select(
u =>
new ResponseUserProfile
{
isFollowed = true,
cantSeguidores = u.seguidores1
.Where(s => s.id_seguido == idUser && s.users.isDeleted == false).ToList().Count,
cantSeguidos = u.seguidores
.Where(s => s.seguidor_id == idUser && s.users1.isDeleted == false).ToList().Count,
UserProfile = new userModel
{
apellido = u.apellido,
descripcion = u.descripcion,
email = u.email,
id_user = u.id_user,
isVendor = u.isVendor,
nombre = u.nombre,
pass = "******",
puntaje = u.puntaje,
username = u.username,
img = u.img,
puesto_name = u.puesto_name,
isActive = u.isActive,
dui = u.dui,
isDeleted = u.isDeleted,
num_telefono = u.num_telefono,
xlat = u.xlat,
ylon = u.ylon
},
}
).ToList().FirstOrDefault();
varUserProfile.publicacionesUser = db.publicaciones
.Where(pu => pu.isDeleted == false && pu.users.isDeleted == false && pu.id_user == idUser)
.Select(
b =>
new ResponsePublicacionFeed
{
publicacion = new publicacionesModel
{
descripcion = b.descripcion,
fecha_actualizacion = b.fecha_actualizacion,
fecha_creacion = b.fecha_creacion,
id_post = b.id_post,
id_user = b.id_user,
img = b.img,
isImg = b.isImg,
isDeleted = b.isDeleted
},
//No lo mando porque ya lo tengo en un JSON y Singleton Localmente
//UsuarioCreator = new userModel()
//{
// apellido = b.users.apellido,
// descripcion = b.users.descripcion,
// email = b.users.email,
// id_user = b.users.id_user,
// isVendor = b.users.isVendor,
// nombre = b.users.nombre,
// pass = "******",
// puntaje = b.users.puntaje,
// username = b.users.username,
// img = b.users.img,
// puesto_name = b.users.puesto_name,
// isActive = b.users.isActive,
// dui = b.users.dui,
// isDeleted = b.users.isDeleted,
// num_telefono = b.users.num_telefono,
// xlat = b.users.xlat,
// ylon = b.users.ylon
//},
cantComentarios = b.comentarios.Where(c => c.users.isDeleted == false && c.isDeleted == false).ToList().Count,
cantLikes = b.like_post.Where(l => l.users.isDeleted == false).ToList().Count,
IsLiked = b.like_post.FirstOrDefault(l => l.id_user == idUser) == default(like_post) ? false : true,
IsSavedPost = b.publicacion_guardada.FirstOrDefault(p => p.id_user == idUser) == default(publicacion_guardada) ? false : true
}
).OrderByDescending(f => f.publicacion.fecha_creacion).ToList();
varUserProfile.publicacionesGuardadas = db.publicacion_guardada
.Where(postSaved => postSaved.id_user == idUser && postSaved.publicaciones.isDeleted == false && postSaved.users.isDeleted == false)
.OrderByDescending(f => f.fecha)
.Select(
b =>
new ResponsePublicacionFeed
{
publicacion = new publicacionesModel
{
descripcion = b.publicaciones.descripcion,
fecha_actualizacion = b.publicaciones.fecha_actualizacion,
fecha_creacion = b.publicaciones.fecha_creacion,
id_post = b.publicaciones.id_post,
id_user = b.publicaciones.id_user,
img = b.publicaciones.img,
isImg = b.publicaciones.isImg,
isDeleted = b.publicaciones.isDeleted
},
UsuarioCreator = new userModel()
{
apellido = b.publicaciones.users.apellido,
descripcion = b.publicaciones.users.descripcion,
email = b.publicaciones.users.email,
id_user = b.publicaciones.users.id_user,
isVendor = b.publicaciones.users.isVendor,
nombre = b.publicaciones.users.nombre,
pass = "******",
puntaje = b.publicaciones.users.puntaje,
username = b.publicaciones.users.username,
img = b.publicaciones.users.img,
puesto_name = b.publicaciones.users.puesto_name,
isActive = b.publicaciones.users.isActive,
dui = b.publicaciones.users.dui,
isDeleted = b.publicaciones.users.isDeleted,
num_telefono = b.publicaciones.users.num_telefono,
xlat = b.publicaciones.users.xlat,
ylon = b.publicaciones.users.ylon
},
IsSavedPost = true,
cantComentarios = b.publicaciones.comentarios.Where(c => c.users.isDeleted == false && c.isDeleted == false).ToList().Count,
cantLikes = b.publicaciones.like_post.Where(l => l.users.isDeleted == false).ToList().Count,
IsLiked = b.publicaciones.like_post.FirstOrDefault(l => l.id_user == idUser) == default(like_post) ? false : true
}
).ToList();
return(Request.CreateResponse(HttpStatusCode.OK, varUserProfile));
}
}
public HttpResponseMessage OtherProfile(int idUserProfile, int idVisitante)
{
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(idUserProfile))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe tal usuario, id: {idUserProfile}"));
}
if (!ValidandoSiExistenDatosRelacionados.ExistsUser(idVisitante))
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"No existe tal usuario, id: {idVisitante}"));
}
using (var db = new DBContextModel())
{
var varUserProfile = db.users
.Include(s => s.publicaciones)
.Include(s => s.like_post)
.Include(s => s.seguidores)
.Include(s => s.seguidores1)
.Include(s => s.publicacion_guardada)
.Where(u => u.id_user == idUserProfile)
.Select(
u =>
new ResponseUserProfile
{
isFollowed = u.seguidores1.FirstOrDefault(ss => ss.seguidor_id == idVisitante) == default(seguidores) ? false : true,
cantSeguidores = u.seguidores1
.Where(s => s.id_seguido == idUserProfile && s.users.isDeleted == false).ToList().Count,
cantSeguidos = u.seguidores
.Where(s => s.seguidor_id == idUserProfile && s.users1.isDeleted == false).ToList().Count,
UserProfile = new userModel
{
apellido = u.apellido,
descripcion = u.descripcion,
email = u.email,
id_user = u.id_user,
isVendor = u.isVendor,
nombre = u.nombre,
pass = "******",
puntaje = u.puntaje,
username = u.username,
img = u.img,
puesto_name = u.puesto_name,
isActive = u.isActive,
dui = u.dui,
isDeleted = u.isDeleted,
num_telefono = u.num_telefono,
xlat = u.xlat,
ylon = u.ylon
},
publicacionesUser = u.publicaciones
.Where(pu => pu.isDeleted == false)
.Select(
b =>
new ResponsePublicacionFeed
{
publicacion = new publicacionesModel
{
descripcion = b.descripcion,
fecha_actualizacion = b.fecha_actualizacion,
fecha_creacion = b.fecha_creacion,
id_post = b.id_post,
id_user = b.id_user,
img = b.img,
isImg = b.isImg,
isDeleted = b.isDeleted
},
cantComentarios = b.comentarios.Where(c => c.users.isDeleted == false && c.isDeleted == false).ToList().Count,
cantLikes = b.like_post.Where(l => l.users.isDeleted == false).ToList().Count,
IsLiked = b.like_post.FirstOrDefault(l => l.id_user == idVisitante) == default(like_post) ? false : true,
IsSavedPost = b.publicacion_guardada.FirstOrDefault(p => p.id_user == idVisitante) == default(publicacion_guardada) ? false : true
}
).OrderByDescending(f => f.publicacion.fecha_creacion).ToList(),
}
).ToList().FirstOrDefault();
return(Request.CreateResponse(HttpStatusCode.OK, varUserProfile));
}
}
