public async Task <BlogResponse> DeleteAsync(string id)
{
var response = new BlogResponse();
var message = await _messages.FindAsync(id.ToObjectId());
if (message is null)
{
response.IsFailed($"The message id not exists.");
return(response);
}
if (message.Reply is not null)
{
if (message.Reply.Any())
{
response.IsFailed($"The reply message is not empty.");
return(response);
}
}
await _messages.DeleteAsync(id.ToObjectId());
return(response);
}
public async Task <BlogResponse <PostDetailDto> > GetPostByUrlAsync(string url)
{
return(await _cache.GetPostByUrlAsync(url, async() =>
{
var response = new BlogResponse <PostDetailDto>();
var post = await _posts.FindAsync(x => x.Url == url);
if (post is null)
{
response.IsFailed($"The post url not exists.");
return response;
}
var previous = _posts.Where(x => x.CreatedAt > post.CreatedAt).Take(1).Select(x => new PostPagedDto
{
Title = x.Title,
Url = x.Url
}).FirstOrDefault();
var next = _posts.Where(x => x.CreatedAt < post.CreatedAt).OrderByDescending(x => x.CreatedAt).Take(1).Select(x => new PostPagedDto
{
Title = x.Title,
Url = x.Url
}).FirstOrDefault();
var result = ObjectMapper.Map <Post, PostDetailDto>(post);
result.Previous = previous;
result.Next = next;
response.Result = result;
return response;
}));
public async Task <BlogResponse <string> > GenerateTokenAsync(string type, string code, string state)
{
var response = new BlogResponse <string>();
if (!StateManager.IsExist(state))
{
response.IsFailed("Request failed.");
return(response);
}
StateManager.Remove(state);
var token = type switch
{
"github" => GenerateToken(await _githubService.GetUserByOAuthAsync(type, code, state)),
"gitee" => GenerateToken(await _giteeService.GetUserByOAuthAsync(type, code, state)),
"alipay" => GenerateToken(await _alipayService.GetUserByOAuthAsync(type, code, state)),
"dingtalk" => GenerateToken(await _dingtalkService.GetUserByOAuthAsync(type, code, state)),
"microsoft" => GenerateToken(await _microsoftService.GetUserByOAuthAsync(type, code, state)),
"weibo" => GenerateToken(await _weiboService.GetUserByOAuthAsync(type, code, state)),
"qq" => GenerateToken(await _qqService.GetUserByOAuthAsync(type, code, state)),
_ => throw new NotImplementedException($"Not implemented:{type}")
};
response.IsSuccess(token);
return(response);
}
public async Task <BlogResponse> ReplyAsync(string id, ReplyMessageInput input)
{
var response = new BlogResponse();
var message = await _messages.FindAsync(id.ToObjectId());
if (message is null)
{
response.IsFailed($"The message id not exists.");
return(response);
}
var reply = message.Reply ?? new List <MessageReply>();
reply.Add(new MessageReply
{
Name = input.Name,
Content = input.Content,
Avatar = input.Avatar,
UserId = input.UserId
});
message.Reply = reply;
await _messages.UpdateAsync(message);
return(response);
}
public async Task <BlogResponse> CreateUserAsync(CreateUserInput input)
{
var response = new BlogResponse();
var user = await _users.FindAsync(x => x.Username == input.Username);
if (user is not null)
{
response.IsFailed("The username already exists.");
return(response);
}
input.Password = input.Password.ToMd5();
await _users.InsertAsync(new User
{
Username = input.Username,
Password = input.Password,
Type = input.Type,
Identity = input.Identity,
Name = input.Name,
Avatar = input.Avatar,
Email = input.Email
});
return(response);
}
public async Task <BlogResponse <List <string> > > Ip2RegionAsync(string ip)
{
var response = new BlogResponse <List <string> >();
if (ip.IsNullOrEmpty())
{
ip = _httpContextAccessor.HttpContext.Request.Headers["X-Real-IP"].FirstOrDefault() ??
_httpContextAccessor.HttpContext.Request.Headers["X-Forwarded-For"].FirstOrDefault() ??
_httpContextAccessor.HttpContext.Connection.RemoteIpAddress.MapToIPv4().ToString();
}
else
{
if (!ip.IsIp())
{
response.IsFailed("The ip address error.");
return(response);
}
}
var path = Path.Combine(Directory.GetCurrentDirectory(), "Resources/ip2region.db");
using var _search = new DbSearcher(path);
var block = await _search.BinarySearchAsync(ip);
var region = block.Region.Split("|").Distinct().Where(x => x != "0").ToList();
region.AddFirst(ip);
response.Result = region;
return(response);
}
public async Task <BlogResponse <string> > GenerateAsync(GenerateSignatureInput input)
{
return(await _cache.GenerateAsync(input, async() =>
{
var response = new BlogResponse <string>();
var ip = _httpContextAccessor.HttpContext.Request.Headers["X-Real-IP"].FirstOrDefault() ??
_httpContextAccessor.HttpContext.Request.Headers["X-Forwarded-For"].FirstOrDefault() ??
_httpContextAccessor.HttpContext.Connection.RemoteIpAddress.MapToIPv4().ToString();
var type = Signature.KnownTypes.Dictionary.FirstOrDefault(x => x.Value == input.TypeId).Key;
if (type.IsNullOrEmpty())
{
response.IsFailed($"The signature type not exists.");
return response;
}
var signature = await _signatures.FindAsync(x => x.Name == input.Name && x.Type == type);
if (signature is not null)
{
response.Result = signature.Url;
return response;
}
var api = _signatureOptions.Urls
.OrderBy(x => GuidGenerator.Create())
.Select(x => new { Url = x.Key, Param = string.Format(x.Value, input.Name, input.TypeId) })
.FirstOrDefault();
var content = new StringContent(api.Param);
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
using var client = _httpClient.CreateClient();
client.DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0");
var httpResponse = await client.PostAsync(api.Url, content);
var httpResult = await httpResponse.Content.ReadAsStringAsync();
var regex = new Regex(@"<img\b[^<>]*?\bsrc[\s\t\r\n]*=[\s\t\r\n]*[""']?[\s\t\r\n]*(?<imgUrl>[^\s\t\r\n""'<>]*)[^<>]*?/?[\s\t\r\n]*>", RegexOptions.IgnoreCase);
var imgUrl = regex.Match(httpResult).Groups["imgUrl"].Value;
var url = $"{$"{input.Name}_{type}".ToMd5()}.png";
var signaturePath = Path.Combine(_signatureOptions.Path, url);
var imgBuffer = await client.GetByteArrayAsync(imgUrl);
await imgBuffer.DownloadAsync(signaturePath);
await _signatures.InsertAsync(new Signature
{
Name = input.Name,
Type = type,
Url = url,
Ip = ip
});
response.Result = url;
return response;
}));
public async Task <BlogResponse <UserDto> > GetCurrentUserAsync()
{
var response = new BlogResponse <UserDto>();
var claim = _principalAccessor.Principal.Claims?.FirstOrDefault((Claim c) => c.Type == ClaimTypes.NameIdentifier);
if (claim == null || claim.Value.IsNullOrWhiteSpace())
{
response.IsFailed("Unauthorized.");
return(response);
}
return(await GetUserAsync(claim.Value));
}
public async Task <BlogResponse> CreateAsync(CreateInput input)
{
var response = new BlogResponse();
if (!input.Content.Any())
{
response.IsFailed("The content list is null.");
return(response);
}
await _sayings.InsertManyAsync(input.Content.Select(x => new Saying {
Content = x.Trim()
}));
return(response);
}
public void OnException(ExceptionContext context)
{
if (context.Exception != null)
{
var result = new BlogResponse();
result.IsFailed(context.Exception.Message);
context.Result = new ContentResult()
{
Content = result.SerializeToJson(),
StatusCode = StatusCodes.Status200OK
};
context.ExceptionHandled = true;
}
}
public async Task <BlogResponse> DeleteUserAsync(string id)
{
var response = new BlogResponse();
var message = await _users.FindAsync(id.ToObjectId());
if (message is null)
{
response.IsFailed($"The user id not exists.");
return(response);
}
await _users.DeleteAsync(id.ToObjectId());
return(response);
}
public async Task <BlogResponse> DeleteCategoryAsync(string id)
{
var response = new BlogResponse();
var category = await _categories.FindAsync(id.ToObjectId());
if (category is null)
{
response.IsFailed($"The category id not exists.");
return(response);
}
await _categories.DeleteAsync(id.ToObjectId());
return(response);
}
public async Task <BlogResponse> DeleteAsync(string id)
{
var response = new BlogResponse();
var saying = await _sayings.FindAsync(id.ToObjectId());
if (saying is null)
{
response.IsFailed($"The saying id not exists.");
return(response);
}
await _sayings.DeleteAsync(id.ToObjectId());
return(response);
}
public async Task <BlogResponse> DeleteFriendLinkAsync(string id)
{
var response = new BlogResponse();
var friendLink = await _friendLinks.FindAsync(id.ToObjectId());
if (friendLink is null)
{
response.IsFailed($"The friendLink id not exists.");
return(response);
}
await _friendLinks.DeleteAsync(id.ToObjectId());
return(response);
}
public async Task <BlogResponse> SettingAdminAsync(string id, bool isAdmin)
{
var response = new BlogResponse();
var user = await _users.FindAsync(id.ToObjectId());
if (user is null)
{
response.IsFailed("The user id is not exists.");
return(response);
}
user.IsAdmin = isAdmin;
await _users.UpdateAsync(user);
return(response);
}
public async Task <BlogResponse <UserDto> > GetUserAsync(string id)
{
var response = new BlogResponse <UserDto>();
var user = await _users.FindAsync(id.ToObjectId());
if (user is null)
{
response.IsFailed("The user id is not exists.");
return(response);
}
var result = ObjectMapper.Map <User, UserDto>(user);
response.IsSuccess(result);
return(response);
}
public async Task <BlogResponse> UpdatePasswordAsync(string id, string password)
{
var response = new BlogResponse();
var user = await _users.FindAsync(id.ToObjectId());
if (user is null)
{
response.IsFailed("The user id is not exists.");
return(response);
}
user.Password = password.ToMd5();
await _users.UpdateAsync(user);
return(response);
}
public async Task <BlogResponse <HotDto> > GetHotsAsync(string id)
{
return(await _cache.GetHotsAsync(id, async() =>
{
var response = new BlogResponse <HotDto>();
var hot = await _hots.GetAsync(id.ToObjectId());
if (hot is null)
{
response.IsFailed($"The hot id not exists.");
return response;
}
var result = ObjectMapper.Map <Hot, HotDto>(hot);
response.Result = result;
return response;
}));
public async Task <BlogResponse> DeleteReplyAsync(string id, string replyId)
{
var response = new BlogResponse();
var message = await _messages.FindAsync(id.ToObjectId());
if (message is null)
{
response.IsFailed($"The message id not exists.");
return(response);
}
message.Reply = message.Reply?.Where(x => x.Id != replyId.ToObjectId()).ToList();
await _messages.UpdateAsync(message);
return(response);
}
public async Task <BlogResponse <PostDto> > GetPostAsync(string id)
{
var response = new BlogResponse <PostDto>();
var post = await _posts.FindAsync(id.ToObjectId());
if (post is null)
{
response.IsFailed($"The post id not exists.");
return(response);
}
var result = ObjectMapper.Map <Post, PostDto>(post);
result.Url = result.Url.Split("-").Last();
response.Result = result;
return(response);
}
public async Task <BlogResponse> UpdateTagAsync(string id, UpdateTagInput input)
{
var response = new BlogResponse();
var tag = await _tags.FindAsync(id.ToObjectId());
if (tag is null)
{
response.IsFailed($"The tag id not exists.");
return(response);
}
tag.Name = input.Name;
tag.Alias = input.Alias;
await _tags.UpdateAsync(tag);
return(response);
}
public async Task <BlogResponse> UpdateFriendLinkAsync(string id, UpdateFriendLinkInput input)
{
var response = new BlogResponse();
var friendLink = await _friendLinks.FindAsync(id.ToObjectId());
if (friendLink is null)
{
response.IsFailed($"The friendLink id not exists.");
return(response);
}
friendLink.Name = input.Name;
friendLink.Url = input.Url;
await _friendLinks.UpdateAsync(friendLink);
return(response);
}
public async Task <BlogResponse <string> > GenerateTokenAsync([Required] string code)
{
var response = new BlogResponse <string>();
var cacheCode = await _authorizeCacheService.GetAuthorizeCodeAsync();
if (code != cacheCode)
{
response.IsFailed("The authorization code is wrong.");
return(response);
}
var user = await _userService.GetDefaultUserAsync();
var token = GenerateToken(user);
response.IsSuccess(token);
return(response);
}
public async Task <BlogResponse> UpdateCategoryAsync(string id, UpdateCategoryInput input)
{
var response = new BlogResponse();
var category = await _categories.FindAsync(id.ToObjectId());
if (category is null)
{
response.IsFailed($"The category id not exists.");
return(response);
}
category.Name = input.Name;
category.Alias = input.Alias;
await _categories.UpdateAsync(category);
return(response);
}
public async Task <BlogResponse> CreateFriendLinkAsync(CreateFriendLinkInput input)
{
var response = new BlogResponse();
var friendLink = await _friendLinks.FindAsync(x => x.Name == input.Name);
if (friendLink is not null)
{
response.IsFailed($"The friendLink:{input.Name} already exists.");
return(response);
}
await _friendLinks.InsertAsync(new FriendLink
{
Name = input.Name,
Url = input.Url
});
return(response);
}
public async Task <BlogResponse> UpdateUserAsync(string id, UpdateUserinput input)
{
var response = new BlogResponse();
var user = await _users.FindAsync(id.ToObjectId());
if (user is null)
{
response.IsFailed("The user id is not exists.");
return(response);
}
user.Username = input.Username;
user.Name = input.Name;
user.Avatar = input.Avatar;
user.Email = input.Email;
await _users.UpdateAsync(user);
return(response);
}
public async Task <BlogResponse> CreateCategoryAsync(CreateCategoryInput input)
{
var response = new BlogResponse();
var category = await _categories.FindAsync(x => x.Name == input.Name);
if (category is not null)
{
response.IsFailed($"The category:{input.Name} already exists.");
return(response);
}
await _categories.InsertAsync(new Category
{
Name = input.Name,
Alias = input.Alias
});
return(response);
}
public async Task <BlogResponse> CreateTagAsync(CreateTagInput input)
{
var response = new BlogResponse();
var tag = await _tags.FindAsync(x => x.Name == input.Name);
if (tag is not null)
{
response.IsFailed($"The tag:{input.Name} already exists.");
return(response);
}
await _tags.InsertAsync(new Tag
{
Name = input.Name,
Alias = input.Alias
});
return(response);
}
private void ConfigureAuthentication(IServiceCollection services)
{
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateAudience = true,
ValidateIssuerSigningKey = true,
ValidateLifetime = true,
RequireExpirationTime = true,
ValidIssuer = AppOptions.Jwt.Issuer,
ValidAudience = AppOptions.Jwt.Audience,
IssuerSigningKey = new SymmetricSecurityKey(AppOptions.Jwt.SigningKey.GetBytes())
};
options.Events = new JwtBearerEvents
{
OnChallenge = async context =>
{
context.HandleResponse();
context.Response.ContentType = "application/json;charset=utf-8";
context.Response.StatusCode = StatusCodes.Status401Unauthorized;
var response = new BlogResponse();
response.IsFailed("Unauthorized");
await context.Response.WriteAsJsonAsync(response);
},
OnMessageReceived = async context =>
{
context.Token = context.Request.Query["token"];
await Task.CompletedTask;
}
};
});
services.AddAuthorization();
}
public async Task <BlogResponse> UpdatePostAsync(string id, UpdatePostInput input)
{
var response = new BlogResponse();
var post = await _posts.FindAsync(id.ToObjectId());
if (post is null)
{
response.IsFailed($"The post id not exists.");
return(response);
}
var tags = await _tags.GetListAsync();
var newTags = input.Tags.Where(item => !tags.Any(x => x.Name == item)).Select(x => new Tag
{
Name = x,
Alias = x.ToLower()
});
if (newTags.Any())
{
await _tags.InsertManyAsync(newTags);
}
post.Title = input.Title;
post.Author = input.Author;
post.Url = input.Url.GeneratePostUrl(input.CreatedAt.ToDateTime());
post.Markdown = input.Markdown;
post.Category = await _categories.GetAsync(input.CategoryId.ToObjectId());
post.Tags = await _tags.GetListAsync(input.Tags);
post.CreatedAt = input.CreatedAt.ToDateTime();
await _posts.UpdateAsync(post);
return(response);
}
