public JsonResult ValidateNumeration([FromBody] SimplifiedReqTemplateViewModel item)
{
//Get Project Numeration
Configuração conf = DBConfigurations.GetById(1);
if (conf != null)
{
int numModReqSimplificadas = conf.NumeraçãoModReqSimplificadas.Value;
ConfiguraçãoNumerações numConf = DBNumerationConfigurations.GetById(numModReqSimplificadas);
//Validate if id is valid
if (!(item.RequisitionTemplateId == "" || item.RequisitionTemplateId == null) && !numConf.Manual.Value)
{
return(Json("A numeração configurada para os modelos de requisição simplificada não permite inserção manual."));
}
else if (item.RequisitionTemplateId == "" && !numConf.Automático.Value)
{
return(Json("É obrigatório inserir o Nº Modelo."));
}
}
else
{
return(Json("Não foi possivel obter as configurações base de numeração."));
}
return(Json(""));
}
/// <summary>
/// Seleciona todas as caronas para lista de usuário recebida
/// </summary>
/// <param name="listUsersID">Lista de usuários</param>
/// <returns>Lista com caronas dos usuário recebidos</returns>
private static List <RidesModel> RetrieveFromListNoFilter(List <Guid> listUsersID)
{
DBConfigurations database = new DBConfigurations();
var listRides = new List <Rides>();
var listRidesModel = new List <RidesModel>();
//Seleciona todas as caronas cadastradas para o mes vigente de cada usuário na lista e que tenham
//acentos disponíveis
foreach (var userID in listUsersID)
{
var listTemp = (from ride in database.Ride
where
(ride.DonorID == userID) &&
(ride.TimeFrom.Month == DateTime.Now.Month) &&
(ride.TimeFrom >= DateTime.Now) &&
(ride.RemainingSeats != 0)
select ride).ToList();
listRides.AddRange(listTemp);
}
foreach (var rideDTO in listRides)
{
listRidesModel.Add(Conversor.RidesToModel(rideDTO));
}
return(listRidesModel);
}
/// <summary>
/// Retorna o nome dado o id do usuário
/// </summary>
/// <param name="userID">ID do usuário a ter o nome pesquisado</param>
/// <returns>Nome do usuário</returns>
public static string RetrieveNameById(Guid userID)
{
DBConfigurations database = new DBConfigurations();
var name = (from user in database.Users where user.ID == userID select user).First().FullName;
return(name);
}
public static UserBanks GetUserBankAccount(Guid userBankId)
{
DBConfigurations database = new DBConfigurations();
var userBankAccount = (from account in database.UserBank where account.ID == userBankId select account).First();
return(userBankAccount);
}
/// <summary>
/// Envia um convite de amizade do usuário userModel para o usuário com ID da guid recebida
/// </summary>
/// <param name="userModel">Usuário logado (usuário que enviou o convite)</param>
/// <param name="friendID">ID do usuário a receber solicitação de amizade</param>
/// <param name="error">Controle de erro</param>
/// <returns>True se enviou solicitação com sucesso ou false</returns>
public static bool InviteFriend(UserModel userModel, Guid friendID, out ErrorEnum error)
{
//Verifica se convite já não foi enviado
DBConfigurations database = new DBConfigurations();
error = ErrorEnum.NoErrors;
try
{
//Se convite não existir, envia
if (!FriendshipManager.AreFriends(userModel.ID, friendID))
{
var newFriendship = new Friendships
{
User_A = userModel.ID,
User_B = friendID,
Approved = false
};
database.Friendships.Add(newFriendship);
database.SaveChanges();
return(true);
}
//Se existir, retorna falso
else
{
error = ErrorEnum.ResendSolicitation;
return(false);
}
}
catch (Exception)
{
error = ErrorEnum.ExceptionError;
return(false);
}
}
/// <summary>
/// Envia uma notificação de aceitação ou negação da carona
/// </summary>
/// <param name="userID">ID do usuário que solicita a carona</param>
/// <param name="driverName">Nome do motorista</param>
/// <param name="accepted">Controla se é uma mensagem de que o motorista aceitou ou cancelou a carona</param>
public static void AddRideRequestNotification(Guid userID, string driverName, bool accepted)
{
DBConfigurations database = new DBConfigurations();
string text = "";
if (accepted)
{
text = driverName + " aceitou sua solicitação de carona.";
}
else
{
text = driverName + " rejeitou sua solicitação de carona.";
}
Notifications not = new Notifications
{
ID = Guid.NewGuid(),
UserID = userID,
Text = text,
New = true
};
NotificationsManager.SendEmailNotification(userID, text);
database.Notifications.Add(not);
database.SaveChanges();
}
/// <summary>
/// Verifica se a ID selecionada para login não existe na base de dados
/// </summary>
/// <param name="loginID">Nome de usuário selecionado</param>
/// <returns>True se usuário existir na base, False se não existir</returns>
public static bool IsUserLoginExist(string userID)
{
DBConfigurations database = new DBConfigurations();
bool exists = (from user in database.User where user.Username == userID select user).Any();
return(exists);
}
/// <summary>
/// Se não definiu nada, ou se definiu só cidade ou idade, busca pelos dois
/// </summary>
/// <param name="city">Cidade para pesquisa</param>
/// <param name="years">Idade para pesquisa</param>
/// <param name="modelCity">Cidade do usuário</param>
/// <param name="modelYear">Ano de nascimento do usuário</param>
/// <returns>Lista com resultados encontrados</returns>
private static List <Users> SearchNoFilters(string city, int?years, string modelCity, int modelYear)
{
DBConfigurations database = new DBConfigurations();
var listRelatedFriends = new List <Users>();
//Se não definiu filtro algum e não tem nenhum amigo, sistema procura
//usuário da mesma cidade com até 10 anos de diferença
if (city.Trim().Length == 0)
{
city = modelCity;
}
if (years == null)
{
years = 10;
}
listRelatedFriends = (from user in database.Users
where
((user.City == city) &&
((user.Birth.Year - modelYear) <= years)) &&
((user.Birth.Year - modelYear) >= -(years))
select user).Take(20).ToList();
return(listRelatedFriends);
}
/// <summary>
/// Verifica se senha digitada corresponde
/// </summary>
/// <param name="Password">Senha inserida</param>
/// <returns>True se verdadeiro, False se falso</returns>
public static bool ValidatePassword(string password, Guid userID, out ErrorEnum errorEnum)
{
DBConfigurations database = new DBConfigurations();
errorEnum = ErrorEnum.NoErrors;
try
{
var encryptPassword = Security.Encrypt(password);
var userDTO = (from user in database.Users where user.ID == userID && user.Password == encryptPassword select user).First();
if (userDTO != null)
{
return(true);
}
else
{
errorEnum = ErrorEnum.InvalidPassword;
return(false);
}
}
catch (Exception ex)
{
errorEnum = ErrorEnum.InvalidPassword;
return(false);
}
}
/// <summary>
/// Efetua o login do usuário e senha caso estes existam
/// </summary>
/// <param name="user">Usuário a ser logado</param>
/// <param name="password">Senha inserida</param>
/// <param name="message">Mensagem de erro para o controle</param>
/// <returns></returns>
public static UserModel LoginUser(string username, string password, out ErrorEnum errorEnum)
{
DBConfigurations database = new DBConfigurations();
try
{
var encryptPassword = Security.Encrypt(password);
var userDTO = (from user in database.Users where user.Username == username && user.Password == encryptPassword select user).First();
if (userDTO != null)
{
var userModel = Conversor.UserDTOToModel(userDTO);
var bankAccountDTO = (from userBank in database.UserBank where userBank.ID == userDTO.UserBankID select userBank).First();
var userBankAccount = Conversor.UserBankToModel(bankAccountDTO);
var bankDTO = (from banks in database.Banks where banks.ID == userBankAccount.BankID select banks).First();
userBankAccount.Name = bankDTO.Nome;
userModel.BankAccount = userBankAccount;
errorEnum = ErrorEnum.NoErrors;
return(userModel);
}
else
{
errorEnum = ErrorEnum.InvalidUsername;
return(null);
}
}
catch (Exception ex)
{
errorEnum = ErrorEnum.InvalidUsername;
return(null);
}
}
/// <summary>
/// Retorna carro com ID passado por parâmetro
/// </summary>
/// <param name="carID">ID do carro a ser pesquisado</param>
/// <returns>CarModel respectivo</returns>
public static CarModel RetrieveCar(Guid carID)
{
DBConfigurations database = new DBConfigurations();
var carDTO = (from car in database.Cars where car.ID == carID select car).First();
return(Conversor.CarsToModel(carDTO));
}
public JsonResult ValidateNumeration([FromBody] ContactViewModel item)
{
//Get Project Numeration
Configuração conf = DBConfigurations.GetById(1);
if (conf != null)
{
int contactsNumerationConfId = conf.NumeraçãoContactos.Value;
ConfiguraçãoNumerações numConf = DBNumerationConfigurations.GetById(contactsNumerationConfId);
//Validate if id is valid
if (!(item.No == "" || item.No == null) && !numConf.Manual.Value)
{
return(Json("A numeração configurada para contactos não permite inserção manual."));
}
else if (item.No == "" && !numConf.Automático.Value)
{
return(Json("É obrigatório inserir o Nº de Contacto."));
}
}
else
{
return(Json("Não foi possivel obter as configurações base de numeração."));
}
return(Json(""));
}
/// <summary>
/// Edita carro passado como parâmetro
/// </summary>
/// <param name="model">CarModel para modificação</param>
/// <param name="result">Controle de erro</param>
/// <returns>True se removido com sucesso, False caso contrário</returns>
public static bool EditCar(CarModel model, out ErrorEnum error)
{
DBConfigurations database = new DBConfigurations();
error = ErrorEnum.NoErrors;
try
{
var carToEdit = database.Cars.First(i => i.ID == model.ID);
//Update
carToEdit.ArConditioning = model.ArConditioning;
carToEdit.Color = model.Color;
carToEdit.Digits = model.Digits;
carToEdit.Make = model.Make;
carToEdit.Model = model.Modelo;
carToEdit.Pet = model.Pet;
carToEdit.Radio = model.Radio;
carToEdit.RENAVAM = model.RENAVAM;
carToEdit.Smoke = model.Smoke;
database.SaveChanges();
return(true);
}
catch (Exception)
{
error = ErrorEnum.ExceptionError;
return(false);
}
}
/// <summary>
/// Busca todsa as socilitações de reserva em aberto para este motorista
/// </summary>
/// <param name="driverID">ID do motorista</param>
/// <returns>Lista com todas as solicitações de reserva</returns>
public static List <RidesRequest> GetAllRequestsByDriver(Guid driverID)
{
DBConfigurations database = new DBConfigurations();
var listRequests = (from requests in database.RidesRequest where requests.DriverID == driverID select requests).ToList();
return(listRequests);
}
/// <summary>
/// Verifica se o CPF selecionado não existe na base de dados
/// </summary>
/// <param name="userCPF">CPF do usuário selecionado</param>
/// <returns>True se o CPF existir e false se não existir</returns>
public static bool CPFUserExist(string userCPF)
{
DBConfigurations database = new DBConfigurations();
bool exists = (from user in database.User where user.CPF == userCPF select user).Any();
return(exists);
}
/// <summary>
/// Aceita solicitação de amizade entre dois usuários
/// </summary>
/// <param name="userID">Usuário que aceitou solicitação</param>
/// <param name="friendID">Usuário que enviou solicitação</param>
/// <param name="result">Controle de erro</param>
/// <returns>True se aceitou com sucesso</returns>
public static bool AcceptFriend(Guid userID, Guid friendID, out ErrorEnum result)
{
DBConfigurations database = new DBConfigurations();
result = ErrorEnum.NoErrors;
try
{
var friendshipSolicitation = database.Friendships.First(request =>
(request.User_A == friendID &&
request.User_B == userID &&
request.Approved == false));
friendshipSolicitation.Approved = true;
Friendships newFriend = new Friendships
{
User_A = userID,
User_B = friendID,
Approved = true
};
database.Friendships.Add(newFriend);
database.SaveChanges();
return(true);
}
catch (Exception)
{
result = ErrorEnum.ExceptionError;
return(false);
}
}
/// <summary>
/// Responsável por criar uma nova carona
/// </summary>
/// <param name="ride"></param>
/// <param name="error"></param>
public static Guid CreateRide(RidesModel ride, out ErrorEnum error)
{
DBConfigurations database = new DBConfigurations();
error = ErrorEnum.NoErrors;
var rideDTO = Conversor.RidesModelToDTO(ride);
rideDTO.ID = Guid.NewGuid();
rideDTO.RemainingSeats = rideDTO.Seats; //se foi recém criada, tem todos os assentos disponíveis
database.Ride.Add(rideDTO);
database.SaveChanges();
int turn = 0;
foreach (var point in ride.Direction.Path)
{
var direction = new Directions
{
ID = Guid.NewGuid(),
Lat = point.Lat,
Long = point.Long,
Position = turn,
Ride_ID = rideDTO.ID
};
turn++;
database.Directions.Add(direction);
}
database.SaveChanges();
return(rideDTO.ID);
}
public static void MarkAsRead(Guid messageID)
{
DBConfigurations database = new DBConfigurations();
var message = database.Messages.First(m => m.ID == messageID);
message.New = false;
database.SaveChanges();
}
public static void RemoveMessage(Guid messageID)
{
DBConfigurations database = new DBConfigurations();
var message = database.Messages.First(m => m.ID == messageID);
database.Messages.Remove(message);
database.SaveChanges();
}
/// <summary>
/// Retorna lista com todas as mensagens do usuário
/// </summary>
/// <param name="userID">ID do usuário</param>
/// <returns>Lista com todas as mensagens do usuário</returns>
private static List <Messages> GetMessages(Guid userID)
{
DBConfigurations database = new DBConfigurations();
var messagesDTO = (from message in database.Messages
where (message.SenderID == userID || message.ReceiverID == userID)
select message).ToList();
return(messagesDTO);
}
private static Guid AddUser(User userDAO, UserBank userBankDAO)
{
DBConfigurations database = new DBConfigurations();
database.User.Add(userDAO);
database.UserBank.Add(userBankDAO);
database.SaveChanges();
return(userDAO.ID);
}
/// <summary>
/// Verifica se usuário aceitou determinada carona
/// </summary>
/// <param name="userID">ID do usuário para verificação</param>
/// <param name="rideID">ID da carona para verificação</param>
/// <returns>True se aceitou. False se não aceitou.</returns>
public static bool IsRideAccepted(Guid userID, Guid rideID)
{
DBConfigurations database = new DBConfigurations();
var isRideAccepted = (from rideUsers in database.RideUsers
where rideUsers.UserID == userID && rideUsers.RideID == rideID
select rideUsers).Any();
return(isRideAccepted);
}
/// <summary>
/// Verifica se usuário solicitou a reserva de uma carona
/// </summary>
/// <param name="userID">ID do usuário</param>
/// <param name="rideID">ID da carona</param>
/// <returns>True se usuário efetuou a reserva, false se não</returns>
public static bool IsRideRequested(Guid userID, Guid rideID)
{
DBConfigurations database = new DBConfigurations();
var isRequested = (from requests in database.RidesRequest
where requests.UserID == userID &&
requests.RideID == rideID
select requests).Any();
return(isRequested);
}
public static void InsertUserCars(Guid userID, Guid carID)
{
DBConfigurations database = new DBConfigurations();
database.UserCars.Add(new UserCars {
CarID = carID,
UserID = userID
});
database.SaveChanges();
}
/// <summary>
/// Recupera apenas algumas informações do usuário
/// </summary>
/// <param name="userID">ID do usuário a ter informações recuperadas</param>
/// <param name="error">Controle de erro</param>
/// <returns>Usuário selecionado</returns>
public static UserModel RetrieveUserLight(Guid userID)
{
DBConfigurations database = new DBConfigurations();
var userDTO = (from user in database.Users where user.ID == userID select user).First();
var userModel = Conversor.UserDTOToModel(userDTO);
userModel.FileContentResult = ImagesManager.RetrieveImage(userModel.ID);
return(userModel);
}
/// <summary>
/// Se defininiu apenas nome, pesquisa por este
/// </summary>
/// <param name="name">Nome solicitado para pesquisa</param>
/// <returns>Lista com resultados encontrados</returns>
private static List <Users> SearchName(string name)
{
DBConfigurations database = new DBConfigurations();
var listRelatedFriends = new List <Users>();
listRelatedFriends = (from user in database.Users
where (user.FullName.Contains(name))
select user).Take(20).ToList();
return(listRelatedFriends);
}
/// <summary>
/// Retorna apenas os IDS de todos os contatos de determinado usuário
/// </summary>
/// <param name="userID">ID do usuário a ter a pesquisa efetuada</param>
/// <returns>Lista com IDS</returns>
public static List <Guid> RetrieveFriendsID(Guid userID)
{
DBConfigurations database = new DBConfigurations();
var friendships = (from friend in database.Friendships
where (friend.User_A == userID) &&
(friend.Approved == true)
select friend.User_B).ToList();
return(friendships);
}
/// <summary>
/// Retorna todas as novas notificações baseadas no usuário recebido
/// </summary>
/// <param name="userId">ID do usuário a ser retornadas as notificações</param>
/// <returns>Lista com todas as notificações não vistas pelo usuário</returns>
public static List <Notifications> GetUserNotifications(Guid userId)
{
DBConfigurations database = new DBConfigurations();
var listNotifications = (from notification in database.Notifications
where ((notification.UserID == userId) &&
(notification.New == true))
select notification).ToList();
return(listNotifications);
}
public JsonResult CreateRecordTechnicalOfPlates([FromBody] RecordTechnicalOfPlatesModelView data)
{
if (data != null)
{
//Get Numeration
bool autoGenId = false;
Configuração conf = DBConfigurations.GetById(1);
int entityNumerationConfId = conf.NumeraçãoFichasTécnicasDePratos.Value;
if (data.PlateNo == "" || data.PlateNo == null)
{
autoGenId = true;
data.PlateNo = DBNumerationConfigurations.GetNextNumeration(entityNumerationConfId, autoGenId, false);
}
if (data.PlateNo != null)
{
data.CreateUser = User.Identity.Name;
var createdItem = DBRecordTechnicalOfPlates.Create(data.ParseToDB());
if (createdItem != null)
{
data = createdItem.ParseToViewModel();
//Update Last Numeration Used
if (autoGenId)
{
ConfiguraçãoNumerações ConfigNumerations = DBNumerationConfigurations.GetById(entityNumerationConfId);
ConfigNumerations.ÚltimoNºUsado = data.PlateNo;
ConfigNumerations.UtilizadorModificação = User.Identity.Name;
DBNumerationConfigurations.Update(ConfigNumerations);
}
data.eReasonCode = 1;
data.eMessage = "Registo criado com sucesso.";
}
else
{
data = new RecordTechnicalOfPlatesModelView();
data.eReasonCode = 2;
data.eMessage = "Ocorreu um erro ao editar o registo.";
}
}
else
{
data.eReasonCode = 2;
data.eMessage = "A numeração configurada não é compativel com a inserida.";
}
}
else
{
data = new RecordTechnicalOfPlatesModelView();
data.eReasonCode = 2;
data.eMessage = "Ocorreu um erro: a linha não pode ser nula.";
}
return(Json(data));
}
/// <summary>
/// Se definiu apenas email, pesquisa por este
/// </summary>
/// <param name="email">Email para pesquisa</param>
/// <returns>Lista com resultados encontrados</returns>
private static List <Users> SearchEmail(string email)
{
DBConfigurations database = new DBConfigurations();
var listRelatedFriends = new List <Users>();
listRelatedFriends = (from user in database.Users
where (user.Email.Contains(email))
select user).Take(20).ToList();
return(listRelatedFriends);
}
