public ActionResult FacebookCallback(string code)
{
var meleeUser = null as UserModel;
var facebookKey = ConfigurationManager.AppSettings["FacebookKey"];
var facebookSecret = ConfigurationManager.AppSettings["FacebookSecret"];
var fb = new FacebookClient();
dynamic result = fb.Post("oauth/access_token", new
{
client_id = facebookKey,
client_secret = facebookSecret,
redirect_uri = FacebookRedirectUri.AbsoluteUri,
code = code
});
var accessToken = result.access_token;
if (Session["challenger"] != null)
{
meleeUser = (UserModel)Session["challenger"];
meleeUser.Connections.Add(_repository.Add(meleeUser.UserId, "Facebook", accessToken, ""));
Session["challenger"] = meleeUser;
}
return(RedirectToAction("MyProfile", "Home", meleeUser));
}
public async Task <Response <ReturnConnectionDTO> > AddConnection(ReceieveConnectionDTO conn)
{
Response <ReturnConnectionDTO> response = new Response <ReturnConnectionDTO>();
var user = await _userManager.FindByNameAsync(conn.UserName_To);
if (user is null)
{
response.Message = $"User with user name ${conn.UserName_To} does not exist";
return(response);
}
conn.UserId_To = user.Id;
var connection = _mapper.Map <Connection>(conn);
var result = await _connectionRepository.Add(connection);
if (result)
{
response.Data = _mapper.Map <ReturnConnectionDTO>(connection);
response.Message = "Connection Added";
response.Success = true;
return(response);
}
response.Message = "Something went wrong";
return(response);
}
public void AddConnection(ConnectionAddRequest request)
{
var dbConnection = new DbConnection
{
Host = request.Hostname,
Port = request.Port,
Username = request.Username,
Password = request.Password,
User = new User {
Id = request.UserId
}
};
_connectionRepository.Add(dbConnection);
}
public Guid SaveConnection(ConnectionModel data, SaveMode saveMode)
{
var connection = connectionRepository.Get(data.Id);
if (saveMode == SaveMode.CreateNew)
{
if (connection != null)
{
throw new DataValidationException(MessageResource.Error_InsertDuplicateKey);
}
connection = new Connection();
connection.Id = Guid.NewGuid();
connectionRepository.Add(connection);
}
else
{
if (connection == null)
{
throw new DataValidationException(string.Format(MessageResource.Error_DataNotFoundForUpdate, "Connection"));
}
}
var isDup = connectionRepository.GetAll().Where(t => t.Id != connection.Id && t.Name == data.Name).Any();
if (isDup)
{
throw new DataValidationException(string.Format(MessageResource.Error_UpdateDuplicateUniqeField, "Name"));
}
connection.DatabaseName = data.DatabaseName;
connection.Description = data.Description;
connection.Name = data.Name;
if (data.IsSetPassword)
{
if (!string.IsNullOrEmpty(data.Password))
{
connection.Password = CryptoHelper.EncryptText(data.Password);
}
else
{
connection.Password = null;
}
}
connection.Server = data.Server;
connection.LocalServer = data.LocalServer;
connection.IsActive = data.IsActive;
unitOfWork.SaveChanges();
return(connection.Id);
}
public async Task <BlResult <ConnectionModel> > SaveAsync(ConnectionModel connectionModel)
{
BlResult <ConnectionModel> blResult = new BlResult <ConnectionModel>();
try
{
if (connectionModel is null)
{
throw new ArgumentNullException(nameof(connectionModel));
}
EnsureTransaction();
var fetchedEntity = await _connectionRepository.GetByIdWithReferencAsync(connectionModel.Id);
fetchedEntity = _mapper.Map(connectionModel, fetchedEntity);
fetchedEntity.OverwritesId = null;
if (connectionModel.Id > 0)
{
_connectionRepository.Edit(fetchedEntity);
}
else
{
fetchedEntity = _connectionRepository.Add(fetchedEntity);
}
await SaveChangesAsync();
blResult.Success(_mapper.Map <ConnectionModel>(fetchedEntity));
}
catch (ArgumentNullException)
{
blResult.Fail(BLErrorCodeTypeEnum.ArgumentIsNull);
}
catch (Exception ex)
{
blResult.Fail(BLErrorCodeTypeEnum.Unknown, ex.Message, ex);
}
return(blResult);
}
//[ServiceFilterAttribute(typeof(ValidationFilterAttribute))]
public ActionResult <ApiResponse <ConnectionDto> > Create(ConnectionCreateDto item)
{
var response = new ApiResponse <ConnectionDto>();
try
{
Connection user = _connectionRepository.Add(_mapper.Map <Connection>(item));
response.Result = _mapper.Map <ConnectionDto>(user);
}
catch (Exception ex)
{
response.Result = null;
response.Success = false;
response.Message = "Internal server error";
_logger.LogError($"Something went wrong: { ex.ToString() }");
return(StatusCode(500, response));
}
return(StatusCode(201, response));
}
public override async Task <SubscribeReply> Subscribe(SubscribeRequest request, ServerCallContext context)
{
try
{
Console.WriteLine($"New client subscribed: {request.Address} {request.Bank}");
var connection = new Connection(request.Address, request.Bank);
await _connectionRepository.Add(connection, context.CancellationToken);
return(await Task.FromResult(new SubscribeReply
{
IsSuccess = true
}));
}
catch (Exception e)
{
Console.WriteLine($"Publishing gRPC message: {e.Message}");
return(await Task.FromResult(new SubscribeReply
{
IsSuccess = false
}));
}
}
