public async Task <List <ToDoListVM> > GetActivities()
{
List <ToDoListVM> activities = new List <ToDoListVM>();
client.DefaultRequestHeaders.Add("Authorization", HttpContext.Session.GetString("Token"));
TokenVM tokenVM = new TokenVM();
tokenVM.Username = HttpContext.Session.GetString("Username");
tokenVM.ExpireToken = Convert.ToInt64(HttpContext.Session.GetString("ExpToken"));
tokenVM.RefreshToken = HttpContext.Session.GetString("RefreshToken");
tokenVM.ExpireRefreshToken = Convert.ToInt64(HttpContext.Session.GetString("ExpRefreshToken"));
if (tokenVM.ExpireToken < DateTime.UtcNow.Ticks && tokenVM.ExpireRefreshToken > DateTime.UtcNow.Ticks)
{
await RefreshToken(tokenVM);
}
else if (tokenVM.ExpireRefreshToken < DateTime.UtcNow.Ticks)
{
return(null);
}
var responseTask = await client.GetAsync("activities/GetAll/" + HttpContext.Session.GetString("Id") + "/" + 3);
activities = await responseTask.Content.ReadAsAsync <List <ToDoListVM> >();
return(activities);
}
public async Task <IActionResult> Login(UserVM loginViewModel)
{
if (ModelState.IsValid)
{
try
{
TokenVM tokenVM = new TokenVM();
tokenVM.Username = loginViewModel.UserName;
tokenVM.Email = loginViewModel.Email;
if (await _userManager.FindByEmailAsync(tokenVM.Email) != null)
{
TokenVM generate = await GenerateToken(tokenVM);
return(Ok(generate));
}
return(BadRequest("User not Found"));
}
catch (Exception e)
{
return(BadRequest(new { message = e }));
}
}
else
{
return(BadRequest("Failed"));
}
}
public async Task <JsonResult> Login([FromBody] LoginVM loginUser)
{
//hash the password
string password = HashString.Hash(loginUser.password, config["salt"]);
var user = await context.Users
.Where(u => u.username == loginUser.username)
.Where(u => u.hashedPassword == password)
.FirstOrDefaultAsync();
if (user != null)
{
//Generate the JWT
GenerateJWT jwtGen = new GenerateJWT();
TokenVM token = jwtGen.Generate(user.username, config);
return(Json(new JSONTokenResponseVM {
message = "Successfully logged in", token = token.token
}));
}
else
{
return(Json(new JSONResponseVM {
success = false, message = "Incorrect login details"
}));
}
}
public async Task <JsonResult> UncheckStatus(int Id)
{
client.DefaultRequestHeaders.Add("Authorization", HttpContext.Session.GetString("Token"));
TokenVM tokenVM = new TokenVM();
tokenVM.Username = HttpContext.Session.GetString("Username");
tokenVM.ExpireToken = Convert.ToInt64(HttpContext.Session.GetString("ExpToken"));
tokenVM.RefreshToken = HttpContext.Session.GetString("RefreshToken");
tokenVM.ExpireRefreshToken = Convert.ToInt64(HttpContext.Session.GetString("ExpRefreshToken"));
if (tokenVM.ExpireToken < DateTime.UtcNow.Ticks && tokenVM.ExpireRefreshToken > DateTime.UtcNow.Ticks)
{
await RefreshToken(tokenVM);
}
else if (tokenVM.ExpireRefreshToken < DateTime.UtcNow.Ticks)
{
return(null);
}
var myContent = JsonConvert.SerializeObject(Id);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var result = client.PutAsync("activities/uncheckStatus/" + Id, byteContent).Result;
return(Json(result));
}
public async Task <IActionResult> Register([FromBody] RegisterVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = new AppUser()
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var result = await _userManager.CreateAsync(user, model.Password);
var jwtSecurityToken = await generateToken(user);
var tokenVM = new TokenVM
{
AccessToken = jwtSecurityToken,
ExpiresIn = (int)TimeSpan.FromDays(Constants.TokenExpiryDays).TotalSeconds,
UserInfo = Mapper.Map <UserVM>(user)
};
return(Ok(tokenVM));
}
public async Task <IActionResult> UserSignUp([FromBody] UserVM userModel)
{
if (await _userManager.FindByEmailAsync(userModel.Email) == null)
{
var user = new User()
{
UserName = userModel.UserName,
Email = userModel.Email,
};
await _userManager.CreateAsync(user, userModel.Password);
var client = new HttpClient();
var baseURL = new Uri($"{_httpContextAccessor.HttpContext.Request.Scheme}://{_httpContextAccessor.HttpContext.Request.Host.ToUriComponent()}");
client.BaseAddress = baseURL;
var tokenModel = new TokenVM
{
Email = userModel.Email,
Password = userModel.Password
};
var tokenModelSerialized = JsonConvert.SerializeObject(tokenModel);
var response = client.PostAsync("/api/token", new StringContent(tokenModelSerialized, Encoding.UTF8, "application/json"));
return(Ok(response.Result.Content.ReadAsStringAsync().Result));
}
else
{
return(Ok("This email already exists"));
}
}
public async Task <Paging> Paging(int status, string keyword, int pageSize, int pageNumber)
{
client.DefaultRequestHeaders.Add("Authorization", HttpContext.Session.GetString("Token"));
TokenVM tokenVM = new TokenVM();
tokenVM.Username = HttpContext.Session.GetString("Username");
tokenVM.ExpireToken = Convert.ToInt64(HttpContext.Session.GetString("ExpToken"));
tokenVM.RefreshToken = HttpContext.Session.GetString("RefreshToken");
tokenVM.ExpireRefreshToken = Convert.ToInt64(HttpContext.Session.GetString("ExpRefreshToken"));
if (tokenVM.ExpireToken < DateTime.UtcNow.Ticks && tokenVM.ExpireRefreshToken > DateTime.UtcNow.Ticks)
{
await RefreshToken(tokenVM);
}
else if (tokenVM.ExpireRefreshToken < DateTime.UtcNow.Ticks)
{
return(null);
}
try
{
var response = await client.GetAsync("activities/paging?Id=" + HttpContext.Session.GetString("Id") + "&status=" + status + "&keyword=" + keyword + "&pageSize=" + pageSize + "&pageNumber=" + pageNumber);
if (response.IsSuccessStatusCode)
{
return(await response.Content.ReadAsAsync <Paging>());
}
}
catch (Exception) { }
return(null);
}
public async Task <IActionResult> SignIn([FromBody] CredentialsVM credentials)
{
var result = await _signInManager.PasswordSignInAsync(credentials.Email, credentials.Password, false, false);
if (!result.Succeeded)
{
return(BadRequest(new ApiError {
Message = "Login failed."
}));
}
var user = await _userManager.FindByEmailAsync(credentials.Email);
if (user == null)
{
return(BadRequest(new ApiError {
Message = "Email not found."
}));
}
TokenVM tokenVM = new TokenVM()
{
token = TokenUtility.CreateToken(user),
expires_at = DateTimeOffset.UtcNow.AddMinutes(20).ToUnixTimeMilliseconds()
};
return(Ok(tokenVM));
}
public async Task <BookFinderVM> Paging(int pageSize, int pageNumber, string keyword)
{
Client.DefaultRequestHeaders.Add("Authorization", HttpContext.Session.GetString("Token"));
TokenVM tokenVM = new TokenVM();
var exptoken = Convert.ToInt64(HttpContext.Session.GetString("Expire"));
var expreftoken = Convert.ToInt64(HttpContext.Session.GetString("ExpireRefreshToken"));
if (exptoken < DateTime.UtcNow.Ticks && expreftoken > DateTime.UtcNow.Ticks)
{
await RefToken(tokenVM);
}
else if (expreftoken < DateTime.UtcNow.Ticks)
{
return(null);
}
try
{
var response = await Client.GetAsync("BookFinders/paging?keyword=" + keyword + "&pageSize=" + pageSize + "&pageNumber=" + pageNumber);
var testing = response;
if (response.IsSuccessStatusCode)
{
var e = await response.Content.ReadAsAsync <BookFinderVM>();
return(e);
}
}
catch (Exception m)
{
}
return(null);
}
public async Task <TokenVM> GenerateToken(TokenVM tokenVM)
{
var user = await _userManager.FindByEmailAsync(tokenVM.Email);
TokenVM response = _tokenService.Get(tokenVM.Email);
var authClaim = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, _configuration["Jwt:Subject"]),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, DateTime.UtcNow.ToString()),
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]));
var signIn = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var acctoken = new JwtSecurityToken(_configuration["Jwt:Issuer"],
_configuration["Jwt:Audience"],
authClaim,
expires: DateTime.UtcNow.AddMinutes(40),
signingCredentials: signIn);
var accessToken = new JwtSecurityTokenHandler().WriteToken(acctoken);
var expirationToken = DateTime.UtcNow.AddMinutes(40).Ticks;
var refreshToken = GenerateRefreshToken();
var expirationRefreshToken = DateTime.UtcNow.AddMinutes(140).Ticks;
TokenVM generate = new TokenVM
{
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Username = user.UserName,
AccessToken = accessToken,
ExpireToken = expirationToken,
RefreshToken = refreshToken,
ExpireRefreshToken = expirationRefreshToken
};
if (response == null)
{
_tokenService.Insert(new TokenVM
{
Email = generate.Email,
AccessToken = generate.AccessToken,
ExpireToken = generate.ExpireToken,
RefreshToken = generate.RefreshToken,
ExpireRefreshToken = generate.ExpireRefreshToken
});
}
else
{
_tokenService.Update(new TokenVM
{
Email = generate.Email,
AccessToken = generate.AccessToken,
ExpireToken = generate.ExpireToken,
RefreshToken = generate.RefreshToken,
ExpireRefreshToken = generate.ExpireRefreshToken
});
}
return(generate);
}
public AddSalonWindow(Salons s, TokenVM _token)
{
InitializeComponent();
this.postalCode.Text = s.PostalCode;
this.city.Text = s.City;
this.address.Text = s.Address;
salonId = s.SalonId;
token = _token;
}
public async Task <JsonResult> CreateAccount([FromBody] CreateAccountVM account)
{
//validate
if (account.username == null || account.password == null || account.password2 == null)
{
return(Json(new JSONResponseVM {
success = false, message = "Please fill out all the fields"
}));
}
if (account.password != account.password2)
{
return(Json(new JSONResponseVM {
success = false, message = "Passwords don't match"
}));
}
//check to see if this username already exists
var query = await context.Users.Where(u => u.username == account.username).FirstOrDefaultAsync();
if (query != null)
{
//this username exists
return(Json(new JSONResponseVM {
success = false, message = "A user with this username already exists"
}));
}
string newPassword = account.password;
newPassword = HashString.Hash(newPassword, config["salt"]);
//now add the new user to the database
User newUser = new User
{
username = account.username,
hashedPassword = newPassword,
//the user is by default a customer
role_id = 0,
role = await context.Roles.Where(r => r.role_id == 0).FirstOrDefaultAsync()
};
context.Users.Add(newUser);
context.SaveChanges();
//generate the token
GenerateJWT jwtGen = new GenerateJWT();
TokenVM tok = jwtGen.Generate(newUser.username, config);
return(Json(new JSONTokenResponseVM {
message = "Successfully created account: " + newUser.username, token = tok.token
}));
}
public static async Task <TokenVM> GenerateJwt(ClaimsIdentity identity, IJwtFactory jwtFactory, string userName, JwtIssuerOptions jwtOptions, JsonSerializerSettings serializerSettings)
{
TokenVM response = new TokenVM()
{
// id = identity.Claims.Single(c => c.Type == "id").Value,
Auth_token = await jwtFactory.GenerateEncodedToken(userName, identity),
Expires_in = (int)jwtOptions.ValidFor.TotalSeconds
};
return(response);
}
public AddCarWindow(Cars c, TokenVM _token)
{
InitializeComponent();
this.make.Text = c.Make;
this.model.Text = c.Model;
this.modelYear.Text = c.ModelYear.ToString();
this.bodyType.Text = c.BodyType;
this.combFuelEco.Text = c.CombFuelEco.ToString();
this.pricePerDay.Text = c.PricePerDay.ToString();
car = c;
token = _token;
}
public AddRenterWindow(Renters r, TokenVM _token)
{
InitializeComponent();
this.name.Text = r.Name;
this.postalCode.Text = r.PostalCode;
this.city.Text = r.City;
this.address.Text = r.Address;
this.email.Text = r.Email;
this.phoneNumber.Text = r.PhoneNumber;
this.rentedDays.Text = r.RentedDays.ToString();
renter = r;
token = _token;
}
public string GetToken(TokenVM tokenVM)
{
var client = new RestClient("https://localhost:44389/api/Authentication/token");
client.Timeout = -1;
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/x-www-form-urlencoded");
request.AddHeader("Cookie", ".AspNetCore.Identity.Application=CfDJ8D_xAUvhPIJOvC-tYFBgkeHG4ZC3RzQUST8CToT2z-RxwVhKtxy8M0ndZnqHvy2XJcswrL28GuVGcGhHXhHIXboNUTHQRI1Xu3oSEsIvxRIfWM2cCdAWT5djpYF4s2z902kfVP_mE-X3dzsEgsOhoz3c1tLF3j7gZy2vW1ACZCsWjhqUFSnvBbjnUXEYkP0DGtcjv3mysvxrucoA34RPL7bXFq_vY13TSAkz5567Igi_Ov1GyDBhUT-vua_vDb0sdWHWKGnGVhOSn-k2BW9bG5x0GCjZqd92GqAnAyoqc3E-mIPZ_CefrueL0IfdvEPTUw; .AspNetCore.Session=CfDJ8D%2FxAUvhPIJOvC%2BtYFBgkeFv9CTqyricnd7sf57kdwzALxQQ18eX9PDskhxAaWmh8PuYVMey18v3KP0eC8Ra%2FgInHq6cLo%2Bye4B5GJRBGkBaIjfttx707cUKnYeMO4OqKLoIUMv3fsK%2BTzyyOpmz3nWCnF7xHoPsbSzh8DMzGglf");
request.AddParameter("email", tokenVM.Email);
request.AddParameter("password", tokenVM.Password);
IRestResponse response = client.Execute(request);
return(response.Content);
}
public int Update(TokenVM tokenVM)
{
parameters.Add("Email", tokenVM.Email);
parameters.Add("AccessToken", tokenVM.AccessToken);
parameters.Add("ExpirationAccessToken", tokenVM.ExpireToken);
parameters.Add("RefreshToken", tokenVM.RefreshToken);
parameters.Add("ExpirationRefreshToken", tokenVM.ExpireRefreshToken);
const string procedure = "SP_UpdateToken";
using (var connection = new SqlConnection(connectionString.Value))
{
var data = connection.Execute(procedure, parameters, commandType: CommandType.StoredProcedure);
return(data);
}
}
public TokenVM Get(string Email)
{
var data = new TokenVM();
try
{
parameters.Add("Email", Email);
const string procedure = "SP_GetToken";
using (var connection = new SqlConnection(connectionString.Value))
{
data = connection.QuerySingleOrDefault <TokenVM>(procedure, parameters, commandType: CommandType.StoredProcedure);
return(data);
}
}
catch (Exception) { }
return(data);
}
public async Task <IActionResult> Post([FromBody] CredentialsViewModel credentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ClaimsIdentity identity = await GetClaimsIdentity(credentials.UserName, credentials.Password);
if (identity == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid username or password.", ModelState)));
}
TokenVM jwt = await Tokens.GenerateJwt(identity, _jwtFactory, credentials.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
public async Task Token([FromBody] TokenVM token)
{
var username = token.username;
var password = token.password;
var identity = await GetIdentity(username, password);
if (identity == null)
{
Response.StatusCode = 400;
await Response.WriteAsync("Invalid username or password.");
return;
}
var now = DateTime.UtcNow;
// создаем JWT-токен
var jwt = new JwtSecurityToken(
issuer: AuthOptions.ISSUER,
audience: AuthOptions.AUDIENCE,
notBefore: now,
claims: identity.Claims,
expires: now.Add(TimeSpan.FromMinutes(AuthOptions.LIFETIME)),
signingCredentials: new SigningCredentials(AuthOptions.GetSymmetricSecurityKey(), SecurityAlgorithms.HmacSha256));
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
// сериализация ответа
var user = await userManager.FindByEmailAsync(identity.Name);
var profile = (await context.UserProfiles.GetAll()).FirstOrDefault(x => x.UserId == user.Id);
var response = new
{
access_token = encodedJwt,
username = user,
profile = profile
};
Response.ContentType = "application/json";
await Response.WriteAsync(JsonConvert.SerializeObject(response, new JsonSerializerSettings {
Formatting = Formatting.Indented
}));
}
public async Task <bool> SetApiToken(TokenVM token)
{
_logger.LogInformation("WaterService.SetApiToken - Service starts.");
var dbToken = new Tokens {
TokenString = token.Token,
Life = token.Duration,
Target = token.Target
};
_dbContext.Tokens.Add(dbToken);
try {
await _dbContext.SaveChangesAsync();
} catch (Exception e) {
_logger.LogError("WaterService.SetApiToken - Error: " + e);
return(false);
}
return(true);
}
public async Task <JsonResult> GetApiToken(string task)
{
_logger.LogInformation("WaterController.GetApiToken - Service starts.");
var tokenLength = HelperProvider.RandomNumberInRange(30, 100);
var token = new TokenVM {
Token = HelperProvider.GenerateRandomString(tokenLength),
Duration = TOKEN_LIFE,
Target = HidroConstants.API_TOKEN_TARGETS[task]
};
var result = await _tokenService.SetApiToken(token);
if (!result)
{
return(new JsonResult(new { Result = RESULTS.FAILED, Message = "An error occurred while attempting to load your photos. Please reload page to try again." }));
}
return(new JsonResult(new { Result = RESULTS.SUCCESS, Message = token.Token }));
}
public static TokenVM GenerateToken(UsuarioModel usuario)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(/*Configuracoes.Secret*/ "csdfdsfasdwsgwes");
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, usuario.Nome),
new Claim(ClaimTypes.Role, usuario.Funcao)
}),
Expires = DateTime.UtcNow.AddHours(2),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenVM = new TokenVM();
tokenVM.Token = tokenHandler.WriteToken(token);
tokenVM.DataExpiracaoToken = (DateTime)tokenDescriptor.Expires;
return(tokenVM);
}
public async Task <IActionResult> GenerateToken([FromBody] TokenVM model)
{
try
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user != null)
{
if (_hasher.VerifyHashedPassword(user, user.PasswordHash, model.Password) == PasswordVerificationResult.Success)
{
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Email, user.Email)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Tokens:Key"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: _config["Tokens:Issuer"],
audience: _config["Tokens:Audience"],
claims: claims,
expires: DateTime.UtcNow.AddDays(30),
signingCredentials: creds
);
return(Ok(
new
{
access_token = new JwtSecurityTokenHandler().WriteToken(token),
expires_on = token.ValidTo
}));
}
}
return(BadRequest(""));
}
catch (Exception ex)
{
return(null);
}
}
public async Task <IActionResult> Refresh(TokenVM tokenViewModel)
{
try
{
TokenVM refToken = _tokenService.Get(tokenViewModel.Username);
if (refToken.ExpireRefreshToken < DateTime.UtcNow.Ticks)
{
return(Unauthorized());
}
if (refToken.RefreshToken == tokenViewModel.RefreshToken)
{
TokenVM generate = await GenerateToken(tokenViewModel);
return(Ok(generate));
}
return(BadRequest());
}
catch (Exception ex)
{
return(Unauthorized(ex));
}
}
public async Task <JsonResult> GetbyID(int Id)
{
IEnumerable <ToDoListVM> toDoList = null;
client.DefaultRequestHeaders.Add("Authorization", HttpContext.Session.GetString("Token"));
TokenVM tokenVM = new TokenVM();
tokenVM.Username = HttpContext.Session.GetString("Username");
tokenVM.ExpireToken = Convert.ToInt64(HttpContext.Session.GetString("ExpToken"));
tokenVM.RefreshToken = HttpContext.Session.GetString("RefreshToken");
tokenVM.ExpireRefreshToken = Convert.ToInt64(HttpContext.Session.GetString("ExpRefreshToken"));
if (tokenVM.ExpireToken < DateTime.UtcNow.Ticks && tokenVM.ExpireRefreshToken > DateTime.UtcNow.Ticks)
{
await RefreshToken(tokenVM);
}
else if (tokenVM.ExpireRefreshToken < DateTime.UtcNow.Ticks)
{
return(null);
}
var responseTask = client.GetAsync("activities/" + Id);
responseTask.Wait();
var result = responseTask.Result;
if (result.IsSuccessStatusCode)
{
var readTask = result.Content.ReadAsAsync <IEnumerable <ToDoListVM> >();
readTask.Wait();
toDoList = readTask.Result;
}
else
{
toDoList = Enumerable.Empty <ToDoListVM>();
ModelState.AddModelError(string.Empty, "Server error try after some time");
}
return(Json(toDoList));
}
public async Task <IActionResult> CreateToken([FromBody] LoginVM model)
{
var user = await _userManager.FindByNameAsync(model.Email);
if (user == null)
{
return(Unauthorized());
}
if (_passwordHasher.VerifyHashedPassword(user, user.PasswordHash, model.Password) == PasswordVerificationResult.Success)
{
var jwtSecurityToken = await generateToken(user);
var tokenVM = new TokenVM
{
AccessToken = jwtSecurityToken,
ExpiresIn = (int)TimeSpan.FromDays(Constants.TokenExpiryDays).TotalSeconds,
UserInfo = Mapper.Map <UserVM>(user)
};
return(Ok(tokenVM));
}
return(Unauthorized());
}
// GET: activities/Delete/5
public async Task <JsonResult> Delete(int id)
{
client.DefaultRequestHeaders.Add("Authorization", HttpContext.Session.GetString("Token"));
TokenVM tokenVM = new TokenVM();
tokenVM.Username = HttpContext.Session.GetString("Username");
tokenVM.ExpireToken = Convert.ToInt64(HttpContext.Session.GetString("ExpToken"));
tokenVM.RefreshToken = HttpContext.Session.GetString("RefreshToken");
tokenVM.ExpireRefreshToken = Convert.ToInt64(HttpContext.Session.GetString("ExpRefreshToken"));
if (tokenVM.ExpireToken < DateTime.UtcNow.Ticks && tokenVM.ExpireRefreshToken > DateTime.UtcNow.Ticks)
{
await RefreshToken(tokenVM);
}
else if (tokenVM.ExpireRefreshToken < DateTime.UtcNow.Ticks)
{
return(null);
}
var result = client.DeleteAsync("activities/" + id).Result;
return(Json(result));
}
