public async Task DeleteAsync(string slug, CancellationToken cancellationToken = default)
{
slug = slug?.Trim().ToLowerInvariant();
if (string.IsNullOrWhiteSpace(slug))
{
return;
}
var fileEntity =
await _fileRepo
.Get(x => x.Slug == slug)
.FirstOrDefaultAsync(cancellationToken: cancellationToken)
.ConfigureAwait(true);
if (fileEntity != null)
{
cancellationToken.ThrowIfCancellationRequested();
_fileRepo.Delete(fileEntity, true);
// Delete Physical File
var filePath = Path.Combine(Directory.GetCurrentDirectory(), SystemSetting.Current.ResourceFolderPath, fileEntity.Slug);
FileHelper.SafeDelete(filePath);
// Save Change
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
}
}
protected async Task <SourceEntity> GetSourceEntity(CancellationToken cancellationToken)
{
Domain = Domain.Trim().Trim('/').ToLowerInvariant();
var sourceEntity = await _sourceRepo
.Get(x => x.Url == Domain)
.FirstOrDefaultAsync(cancellationToken)
.ConfigureAwait(true);
if (sourceEntity == null)
{
sourceEntity = new SourceEntity
{
Name = Name,
Url = Domain,
TimeSpent = TimeSpan.Zero,
LastCrawledPostUrl = null
};
_sourceRepo.Add(sourceEntity);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
}
StopAtPostUrl =
sourceEntity.LastCrawledPostUrl
?.Replace("http://", string.Empty)
.Replace("https://", string.Empty).Trim('/');
return(sourceEntity);
}
public async Task <GoblinIdentityEmailConfirmationModel> RequestConfirmEmailAsync(long id, CancellationToken cancellationToken = default)
{
var userEntity = await _userRepo.Get(x => x.Id == id).FirstOrDefaultAsync(cancellationToken).ConfigureAwait(true);
if (userEntity == null)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.UserNotFound), GoblinIdentityErrorCode.UserNotFound);
}
if (userEntity.EmailConfirmedTime != null)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.EmailAlreadyConfirmed), GoblinIdentityErrorCode.EmailAlreadyConfirmed);
}
var resetConfirmEmailTokenModel = new GoblinIdentityEmailConfirmationModel
{
Id = id,
EmailConfirmToken = userEntity.EmailConfirmToken = StringHelper.Generate(6, false, false),
EmailConfirmTokenExpireTime = userEntity.EmailConfirmTokenExpireTime = GoblinDateTimeHelper.SystemTimeNow.Add(SystemSetting.Current.EmailConfirmTokenLifetime)
};
_userRepo.Update(userEntity,
x => x.EmailConfirmToken,
x => x.EmailConfirmTokenExpireTime
);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
return(resetConfirmEmailTokenModel);
}
public async Task <GoblinIdentityResetPasswordTokenModel> RequestResetPasswordAsync(
GoblinIdentityRequestResetPasswordModel model,
CancellationToken cancellationToken = default)
{
var userEntity = await _userRepo.Get(x => x.Email == model.Email && x.EmailConfirmedTime != null)
.FirstOrDefaultAsync(cancellationToken).ConfigureAwait(true);
if (userEntity == null)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.UserNotFound),
GoblinIdentityErrorCode.UserNotFound);
}
var resetPasswordTokenModel = new GoblinIdentityResetPasswordTokenModel
{
SetPasswordToken = userEntity.SetPasswordToken = StringHelper.Generate(6, false, false),
SetPasswordTokenExpireTime = userEntity.SetPasswordTokenExpireTime = GoblinDateTimeHelper.SystemTimeNow.Add(SystemSetting.Current.SetPasswordTokenLifetime)
};
_userRepo.Update(userEntity,
x => x.SetPasswordToken,
x => x.SetPasswordTokenExpireTime
);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
return(resetPasswordTokenModel);
}
public async Task UpdateProfileAsync(long id, GoblinIdentityUpdateProfileModel model,
CancellationToken cancellationToken = default)
{
var userEntity = await _userRepo.Get(x => x.Id == id)
.FirstOrDefaultAsync(cancellationToken)
.ConfigureAwait(true);
if (userEntity == null)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.UserNotFound),
GoblinIdentityErrorCode.UserNotFound);
}
using var transaction =
await GoblinUnitOfWork.BeginTransactionAsync(cancellationToken).ConfigureAwait(true);
if (model.IsUpdateRoles)
{
_userRoleRepo.DeleteWhere(x => x.UserId == userEntity.Id);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
// User Roles
if (model.Roles?.Any() == true)
{
model.Roles = model.Roles.Select(x => x.Trim()).ToList();
var roleEntities = await _roleRepo.Get(x => model.Roles.Contains(x.Name))
.ToListAsync(cancellationToken).ConfigureAwait(true);
foreach (var roleEntity in roleEntities)
{
_userRoleRepo.Add(new UserRoleEntity
{
UserId = userEntity.Id,
RoleId = roleEntity.Id
});
}
}
}
model.MapTo(userEntity);
_userRepo.Update(userEntity,
x => x.AvatarUrl,
x => x.FullName,
x => x.Bio,
x => x.GithubId,
x => x.SkypeId,
x => x.FacebookId,
x => x.WebsiteUrl,
x => x.CompanyName,
x => x.CompanyUrl
);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
transaction.Commit();
}
public async Task ResetPasswordAsync(GoblinIdentityResetPasswordModel model,
CancellationToken cancellationToken = default)
{
var userEntity = await _userRepo.Get(x => x.Email == model.Email && x.EmailConfirmedTime != null)
.FirstOrDefaultAsync(cancellationToken).ConfigureAwait(true);
if (userEntity == null)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.UserNotFound),
GoblinIdentityErrorCode.UserNotFound);
}
if (userEntity.SetPasswordToken == model.SetPasswordToken)
{
if (userEntity.SetPasswordTokenExpireTime < GoblinDateTimeHelper.SystemTimeNow)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.SetPasswordTokenExpired),
GoblinIdentityErrorCode.SetPasswordTokenExpired);
}
}
else
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.SetPasswordTokenInCorrect),
GoblinIdentityErrorCode.SetPasswordTokenInCorrect);
}
var changedProperties = new List <string>();
var newPasswordHashWithOldSalt =
PasswordHelper.HashPassword(model.NewPassword, userEntity.PasswordLastUpdatedTime);
// If user have changed password, then update password and related information
if (newPasswordHashWithOldSalt != userEntity.PasswordHash)
{
userEntity.PasswordLastUpdatedTime =
userEntity.RevokeTokenGeneratedBeforeTime = GoblinDateTimeHelper.SystemTimeNow;
changedProperties.Add(nameof(userEntity.PasswordLastUpdatedTime));
changedProperties.Add(nameof(userEntity.RevokeTokenGeneratedBeforeTime));
userEntity.PasswordHash =
PasswordHelper.HashPassword(model.NewPassword, userEntity.PasswordLastUpdatedTime);
changedProperties.Add(nameof(userEntity.PasswordHash));
}
userEntity.SetPasswordToken = null;
changedProperties.Add(nameof(userEntity.SetPasswordToken));
userEntity.SetPasswordTokenExpireTime = null;
changedProperties.Add(nameof(userEntity.SetPasswordTokenExpireTime));
_userRepo.Update(userEntity, changedProperties.ToArray());
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
}
public async Task DeleteAsync(long id, CancellationToken cancellationToken = default)
{
var sampleEntity =
await _sampleRepo
.Get(x => x.Id == id)
.FirstOrDefaultAsync(cancellationToken: cancellationToken)
.ConfigureAwait(true);
_sampleRepo.Delete(sampleEntity);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
}
public async Task <GoblinApi_BaseSampleModel> CreateAsync(GoblinApi_BaseCreateSampleModel model,
CancellationToken cancellationToken = default)
{
var sampleEntity = model.MapTo <SampleEntity>();
_sampleRepo.Add(sampleEntity);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
var fileModel = sampleEntity.MapTo <GoblinApi_BaseSampleModel>();
return(fileModel);
}
public virtual async Task CrawlPostsAsync(CancellationToken cancellationToken = default)
{
var startTime = GoblinDateTimeHelper.SystemTimeNow;
var sourceEntity = await GetSourceEntity(cancellationToken);
var crawledPostUrl = await CrawlPostUrlAsync(cancellationToken).ConfigureAwait(true);
var postUrls = crawledPostUrl.TakeWhile(url => url != sourceEntity.LastCrawledPostUrl).ToList();
var postsMetadata = await GoblinCrawlerHelper.GetListMetadataModelsAsync(postUrls).ConfigureAwait(true);
using var transaction =
await GoblinUnitOfWork.BeginTransactionAsync(cancellationToken).ConfigureAwait(true);
// Posts Metadata to Post Crawled Database
await GoblinCrawlerHelper.SavePostEntitiesAsync(Domain, postsMetadata, startTime, _postRepo, GoblinUnitOfWork).ConfigureAwait(true);
// Update Source
sourceEntity.LastCrawlStartTime = startTime;
sourceEntity.LastCrawlEndTime = GoblinDateTimeHelper.SystemTimeNow;
sourceEntity.TimeSpent = sourceEntity.LastCrawlEndTime.Subtract(sourceEntity.LastCrawlStartTime);
sourceEntity.TotalPostCrawledLastTime = postsMetadata.Count;
sourceEntity.TotalPostCrawled += postsMetadata.Count;
if (!string.IsNullOrWhiteSpace(postsMetadata.FirstOrDefault()?.OriginalUrl))
{
sourceEntity.LastCrawledPostUrl = postsMetadata.FirstOrDefault()?.OriginalUrl;
}
_sourceRepo.Update(sourceEntity,
x => x.LastCrawlStartTime,
x => x.LastCrawlEndTime,
x => x.TimeSpent,
x => x.TotalPostCrawledLastTime,
x => x.TotalPostCrawled,
x => x.LastCrawledPostUrl
);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
transaction.Commit();
}
public async Task DeleteAsync(long id, CancellationToken cancellationToken = default)
{
var userEntity =
await _userRepo
.Get(x => x.Id == id)
.FirstOrDefaultAsync(cancellationToken: cancellationToken)
.ConfigureAwait(true);
if (userEntity == null)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.UserNotFound),
GoblinIdentityErrorCode.UserNotFound);
}
_userRepo.Delete(userEntity);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
}
public async Task ConfirmEmail(long id, GoblinIdentityConfirmEmailModel model,
CancellationToken cancellationToken = default)
{
var userEntity = await _userRepo.Get(x => x.Id == id).FirstOrDefaultAsync(cancellationToken).ConfigureAwait(true);
if (userEntity == null)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.UserNotFound),
GoblinIdentityErrorCode.UserNotFound);
}
if (userEntity.EmailConfirmToken == model.EmailConfirmToken)
{
if (userEntity.EmailConfirmTokenExpireTime < GoblinDateTimeHelper.SystemTimeNow)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.ConfirmEmailTokenExpired),
GoblinIdentityErrorCode.ConfirmEmailTokenExpired);
}
}
else
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.ConfirmEmailTokenInCorrect),
GoblinIdentityErrorCode.ConfirmEmailTokenInCorrect);
}
userEntity.EmailConfirmToken = null;
userEntity.EmailConfirmTokenExpireTime = null;
userEntity.EmailConfirmedTime = GoblinDateTimeHelper.SystemTimeNow;
_userRepo.Update(userEntity,
x => x.EmailConfirmToken,
x => x.EmailConfirmTokenExpireTime,
x => x.EmailConfirmedTime
);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
}
public async Task <GoblinResourceFileModel> SaveAsync(GoblinResourceUploadFileModel model, CancellationToken cancellationToken = default)
{
FileServiceHelper.Correct(model);
var fileEntity = model.MapTo <FileEntity>();
fileEntity.Hash = SecurityHelper.EncryptSha256(model.ContentBase64);
var fileBytes = Convert.FromBase64String(model.ContentBase64);
var imageInfo = ImageHelper.GetImageInfo(fileBytes);
// Fill information based on File is Image or not
FileServiceHelper.FillInformation(imageInfo, fileEntity);
cancellationToken.ThrowIfCancellationRequested();
string fileName;
// Save Files
if (imageInfo != null)
{
// Main Image
var isNeedResizeImage = model.ImageMaxHeightPx < fileEntity.ImageHeightPx ||
model.ImageMaxWidthPx < fileEntity.ImageWidthPx;
fileBytes = FileServiceHelper.ResizeAndCompressImage(fileBytes,
isNeedResizeImage,
model.ImageMaxWidthPx.Value,
model.ImageMaxHeightPx.Value,
model.IsEnableCompressImage);
if (model.IsEnableCompressImage)
{
fileEntity.IsCompressedImage = true;
}
// Refill information after resize and compress
if (isNeedResizeImage || model.IsEnableCompressImage)
{
var newImageInfo = ImageHelper.GetImageInfo(fileBytes);
FileServiceHelper.FillInformation(newImageInfo, fileEntity);
}
// Save File
fileName = FileServiceHelper.GenerateFileName(fileEntity.Name, imageInfo);
fileEntity.Slug = FileServiceHelper.SaveFile(fileBytes, model.Folder, fileName, string.Empty, fileEntity.Extension);
fileEntity.ContentLength = fileBytes.Length;
// --------------------------
// Save More Image Size
// --------------------------
// Image Skeleton
var imageSkeletonBytes = FileServiceHelper.ResizeAndCompressImage(fileBytes,
true,
SystemSetting.Current.ImageSkeletonMaxWidthPx,
SystemSetting.Current.ImageSkeletonMaxHeightPx,
true);
FileServiceHelper.SaveFile(imageSkeletonBytes, model.Folder, fileName, "-s", fileEntity.Extension);
// Image Thumbnail
var imageThumbnailBytes = FileServiceHelper.ResizeAndCompressImage(fileBytes,
true,
SystemSetting.Current.ImageThumbnailMaxWidthPx,
SystemSetting.Current.ImageThumbnailMaxHeightPx,
true);
FileServiceHelper.SaveFile(imageThumbnailBytes, model.Folder, fileName, "-t", fileEntity.Extension);
}
else
{
fileName = FileServiceHelper.GenerateFileName(fileEntity.Name, null);
fileEntity.Slug = FileServiceHelper.SaveFile(fileBytes, model.Folder, fileName, string.Empty, fileEntity.Extension);
fileEntity.ContentLength = fileBytes.Length;
}
_fileRepo.Add(fileEntity);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
// Response
var fileModel = fileEntity.MapTo <GoblinResourceFileModel>();
return(fileModel);
}
public async Task <GoblinIdentityRoleModel> UpsertAsync(GoblinIdentityUpsertRoleModel model,
CancellationToken cancellationToken = default)
{
using var transaction =
await GoblinUnitOfWork.BeginTransactionAsync(cancellationToken).ConfigureAwait(true);
// Handle Role
var roleEntity = await _roleRepo
.Get(x => x.Name == model.Name)
.FirstOrDefaultAsync(cancellationToken)
.ConfigureAwait(true);
if (roleEntity == null)
{
roleEntity = new RoleEntity
{
Name = model.Name
};
_roleRepo.Add(roleEntity);
}
// Save Change
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken);
// Handle Permission
if (model.Permissions?.Any() == true)
{
model.Permissions = model.Permissions.Select(x => x.Trim()).ToList();
var existsPermissionEntities =
await _permissionRepo
.Get(x => model.Permissions.Contains(x.Name))
.ToListAsync(cancellationToken).ConfigureAwait(true);
var existsPermissions = existsPermissionEntities.Select(x => x.Name).ToList();
foreach (var permission in model.Permissions)
{
if (!existsPermissions.Contains(permission))
{
var permissionEntity = new PermissionEntity
{
Name = permission
};
_permissionRepo.Add(permissionEntity);
existsPermissionEntities.Add(permissionEntity);
}
}
// Save Change
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
// Relationship Role and Permission
var rolePermissions = await _rolePermissionRepo.Get(x => x.RoleId == roleEntity.Id)
.ToListAsync(cancellationToken)
.ConfigureAwait(true);
foreach (var permissionEntity in existsPermissionEntities)
{
if (rolePermissions.Any(x => x.PermissionId == permissionEntity.Id))
{
continue;
}
_rolePermissionRepo.Add(new RolePermissionEntity
{
RoleId = roleEntity.Id,
PermissionId = permissionEntity.Id
});
}
// Save Change
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
}
transaction.Commit();
var roleModel = await GetAsync(roleEntity.Name, cancellationToken).ConfigureAwait(true);
return(roleModel);
}
public async Task <GoblinIdentityEmailConfirmationModel> UpdateIdentityAsync(long id,
GoblinIdentityUpdateIdentityModel model,
CancellationToken cancellationToken = default)
{
model.NewEmail = model.NewEmail?.Trim().ToLowerInvariant();
model.NewUserName = model.NewUserName?.Trim().ToLowerInvariant();
var userEntity = await _userRepo.Get(x => x.Id == id)
.FirstOrDefaultAsync(cancellationToken)
.ConfigureAwait(true);
if (userEntity == null)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.UserNotFound), GoblinIdentityErrorCode.UserNotFound);
}
var currentPasswordHashWithOldSalt = PasswordHelper.HashPassword(model.CurrentPassword, userEntity.PasswordLastUpdatedTime);
if (currentPasswordHashWithOldSalt != userEntity.PasswordHash)
{
throw new GoblinException(nameof(GoblinIdentityErrorCode.WrongPassword), GoblinIdentityErrorCode.WrongPassword);
}
var emailConfirmationModel = new GoblinIdentityEmailConfirmationModel
{
Id = userEntity.Id
};
var changedProperties = new List <string>();
// Update Password
if (!string.IsNullOrWhiteSpace(model.NewPassword))
{
var newPasswordHashWithOldSalt = PasswordHelper.HashPassword(model.NewPassword, userEntity.PasswordLastUpdatedTime);
// If user have changed password, then update password and related information
if (newPasswordHashWithOldSalt != userEntity.PasswordHash)
{
userEntity.PasswordLastUpdatedTime =
userEntity.RevokeTokenGeneratedBeforeTime = GoblinDateTimeHelper.SystemTimeNow;
changedProperties.Add(nameof(userEntity.PasswordLastUpdatedTime));
changedProperties.Add(nameof(userEntity.RevokeTokenGeneratedBeforeTime));
userEntity.PasswordHash =
PasswordHelper.HashPassword(model.NewPassword, userEntity.PasswordLastUpdatedTime);
changedProperties.Add(nameof(userEntity.PasswordHash));
}
}
// Update Email
if (!string.IsNullOrWhiteSpace(model.NewEmail) && model.NewEmail != userEntity.Email)
{
CheckUniqueEmail(model.NewEmail);
userEntity.EmailConfirmToken = StringHelper.Generate(6, false, false);
changedProperties.Add(nameof(userEntity.EmailConfirmToken));
userEntity.EmailConfirmTokenExpireTime = GoblinDateTimeHelper.SystemTimeNow.Add(SystemSetting.Current.EmailConfirmTokenLifetime);
changedProperties.Add(nameof(userEntity.EmailConfirmTokenExpireTime));
// Email Confirmation Token
emailConfirmationModel.EmailConfirmToken = userEntity.EmailConfirmToken;
emailConfirmationModel.EmailConfirmTokenExpireTime = userEntity.EmailConfirmTokenExpireTime;
}
// Update UserName
if (!string.IsNullOrWhiteSpace(model.NewUserName))
{
CheckUniqueUserName(model.NewUserName);
userEntity.UserName = model.NewUserName;
changedProperties.Add(nameof(userEntity.UserName));
}
if (!changedProperties.Any())
{
return(emailConfirmationModel);
}
_userRepo.Update(userEntity, changedProperties.ToArray());
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
return(emailConfirmationModel);
}
public async Task <GoblinIdentityEmailConfirmationModel> RegisterAsync(GoblinIdentityRegisterModel model,
CancellationToken cancellationToken = default)
{
model.Email = model.Email?.Trim().ToLowerInvariant();
model.UserName = model.UserName?.Trim().ToLowerInvariant();
CheckUniqueEmail(model.Email);
CheckUniqueUserName(model.UserName);
using var transaction =
await GoblinUnitOfWork.BeginTransactionAsync(cancellationToken).ConfigureAwait(true);
var userEntity = model.MapTo <UserEntity>();
userEntity.PasswordLastUpdatedTime =
userEntity.RevokeTokenGeneratedBeforeTime = GoblinDateTimeHelper.SystemTimeNow;
userEntity.PasswordHash =
PasswordHelper.HashPassword(model.Password, userEntity.PasswordLastUpdatedTime);
userEntity.EmailConfirmToken = StringHelper.Generate(6, false, false);
userEntity.EmailConfirmTokenExpireTime =
GoblinDateTimeHelper.SystemTimeNow.Add(SystemSetting.Current.EmailConfirmTokenLifetime);
_userRepo.Add(userEntity);
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
// User Roles
if (model.Roles?.Any() == true)
{
model.Roles = model.Roles.Select(x => x.Trim()).ToList();
var roleEntities = await _roleRepo.Get(x => model.Roles.Contains(x.Name)).ToListAsync(cancellationToken)
.ConfigureAwait(true);
foreach (var roleEntity in roleEntities)
{
_userRoleRepo.Add(new UserRoleEntity
{
UserId = userEntity.Id,
RoleId = roleEntity.Id
});
}
await GoblinUnitOfWork.SaveChangesAsync(cancellationToken).ConfigureAwait(true);
}
transaction.Commit();
// Email Confirmation Code
var emailConfirmationModel = new GoblinIdentityEmailConfirmationModel
{
Id = userEntity.Id,
EmailConfirmToken = userEntity.EmailConfirmToken,
EmailConfirmTokenExpireTime = userEntity.EmailConfirmTokenExpireTime
};
return(emailConfirmationModel);
}