public User Authenticate(string email, string password)
{
Core.Data.DataProvider db = Core.Data.DataProvider.DataProviderFactory();
var user = db.GetUser(email, password);
// return null if user not found
if (user == null)
{
return(null);
}
// authentication successful so generate jwt token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.guid.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
Entities.User eUser = new User();
eUser.Email = user.email;
eUser.Username = user.username;
eUser.Password = user.password;
eUser.GUID = user.guid.ToString();
eUser.Token = user.JWT = tokenHandler.WriteToken(token);
db.Update(user);
return(eUser.WithoutPassword());
}
/// <summary>
/// Register a new account in database
/// </summary>
/// <param name="username">User name</param>
/// <param name="email">Email</param>
/// <param name="password">Password</param>
/// <returns>returns true if user added to database</returns>
public bool Register(string email, string username, string password)
{
Core.Data.User user = new Core.Data.User();
user.email = email;
user.username = username;
user.password = password;
Core.Data.DataProvider db = Core.Data.DataProvider.DataProviderFactory();
return(db.Insert(user));
}
public IActionResult GetAllDistances(Entities.User user)
{
try
{
Core.Data.DataProvider db = Core.Data.DataProvider.DataProviderFactory();
if (user.GUID == null)
{
return(Ok(db._data["GeoData"]));
}
return(Ok(db._data["GeoData"].Where(x => x.Value.Contains(user.GUID))));
}
catch (System.Exception)
{
return(NotFound("Nothing found"));
}
}
public static Model.DataProvider FromDataModel(Core.Data.DataProvider source)
{
if (source == null)
{
return(null);
}
return(new Model.DataProvider
{
ID = source.ID,
Title = source.Title,
WebsiteURL = source.WebsiteURL,
Comments = source.Comments,
DataProviderStatusType = DataProviderStatusType.FromDataModel(source.DataProviderStatusType),
IsRestrictedEdit = source.IsRestrictedEdit,
IsOpenDataLicensed = source.IsOpenDataLicensed,
IsApprovedImport = source.IsApprovedImport,
License = source.License
});
}
public void Publish <T>(T message, string exchangeName, string exchangeType, string routeKey)
where T : class
{
if (message == null)
{
return;
}
var channel = _objectPool.Get();
try
{
channel.ExchangeDeclare(exchangeName, exchangeType, true, false, null);
var sendBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message));
// var SerializeObject = new System.Xml.Serialization.XmlSerializer(typeof(GeoPoints));
// var sendBytes = Encoding.UTF8.GetBytes(Serialize(message));
var properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.MessageId = Guid.NewGuid().ToString();
var typeName = typeof(T).FullName;
properties.Headers = new Dictionary <string, object> {
{ "NServiceBus.EnclosedMessageTypes", typeName }
};
var correlationId = Guid.NewGuid().ToString();
properties.CorrelationId = correlationId;
string replyQueueName = "RabbitMQ";//channel.QueueDeclare().QueueName;
properties.ReplyTo = replyQueueName;
EventingBasicConsumer consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var response = Encoding.UTF8.GetString(body);
var msg = JsonConvert.DeserializeObject <GeoPoints>(response.Substring(1));
if (msg != null)
{
Core.Data.DataProvider db = Core.Data.DataProvider.DataProviderFactory();
// Insert into database
bool res = db.Insert(new Core.Data.GeoData()
{
Distance = msg.Distance,
StartingLat = msg.StartingLat,
StartingLng = msg.StartingLng,
EndingLat = msg.EndingLat,
EndingLng = msg.EndingLng,
UserGUID = msg.UserGUID
});
}
((EventingBasicConsumer)model).Model.BasicAck(ea.DeliveryTag, false);
};
channel.BasicConsume(
consumer: consumer,
queue: replyQueueName,
autoAck: false);
channel.BasicPublish(exchangeName, routeKey, properties, sendBytes);
}
catch (Exception ex)
{
throw ex;
}
finally
{
_objectPool.Return(channel);
}
}
/// <summary>
/// Remove token
/// </summary>
/// <param name="jwt">Token to be removed</param>
/// <returns>Returns true if valid otherwise false</returns>
public bool Logout(string jwt)
{
Core.Data.DataProvider db = Core.Data.DataProvider.DataProviderFactory();
return(db.RemoveUser(jwt));
}
/// <summary>
/// Validate token
/// </summary>
/// <param name="jwt">Token to be validated</param>
/// <returns>Returns true if valid otherwise false</returns>
public bool Validate(string jwt)
{
Core.Data.DataProvider db = Core.Data.DataProvider.DataProviderFactory();
return(db.ValidateJWT(jwt));
}
