public static NewsRecommendedQuestionViewModel MapNewsRecommendedQuestionsViewModel(
this NewsRecommendedQuestionDto dto, MediaConverter mediaConverter, IEnumerable <TagDb> dbTags, IEnumerable <PhotoDb> dbFirstPhotos,
IEnumerable <PhotoDb> dbSecondPhotos, BackgroundSizeType backgroundSizeType)
{
var viewModel =
QuestionDbToViewModel <NewsRecommendedQuestionViewModel>(dto, mediaConverter, dbTags, dbFirstPhotos,
dbSecondPhotos, backgroundSizeType);
viewModel.RecommendedUsers = new List <NewsUserViewModel>(dto.RecommendedUsers.Count);
foreach (var user in dto.RecommendedUsers)
{
viewModel.RecommendedUsers.Add(new NewsUserViewModel
{
UserId = user.UserId,
Login = user.FirstName + " " + user.LastName,
SexType = user.SexType
});
}
viewModel.Priority = dto.Priority;
viewModel.NewsType = NewsType.Recommended;
return(viewModel);
}
public string ToFullBackgroundurlUrl(string shortOriginalUrl, BackgroundSizeType backgroundSize)
{
if (string.IsNullOrEmpty(shortOriginalUrl))
{
return(null);
}
if (shortOriginalUrl.Contains(MediaUrl))
{
shortOriginalUrl = shortOriginalUrl.Replace(MediaUrl, "");
}
var name = Path.GetFileName(shortOriginalUrl);
shortOriginalUrl = Path.GetDirectoryName(string.Concat(shortOriginalUrl.SkipWhile(x => x == '/')));
if (backgroundSize == BackgroundSizeType.Original)
{
return(MediaUrl + shortOriginalUrl.Replace("\\", "/") + '/' + name);
}
name = name.Replace("original", backgroundSize.ToString().ToLower());
switch (backgroundSize)
{
case BackgroundSizeType.Mobile:
return(MediaUrl + shortOriginalUrl.Replace("\\", "/").Replace(new OriginalSizeFolder(null).HashName,
new MobileBackgroundSizeFolder(null).HashName) + '/' + name);
default: throw new Exception($"There is no such background size {backgroundSize}");
}
}
public static UserFavoriteQuestionsViewModel MapToUserFavoriteQuestionsViewModel(
this UserFavoriteQuestionDb dbEntity, MediaConverter mediaConverter, IEnumerable <TagDb> dbTags, IEnumerable <PhotoDb> dbFirstPhotos,
IEnumerable <PhotoDb> dbSecondPhotos, BackgroundSizeType backgroundSizeType)
{
var viewModel =
QuestionDbToViewModel <UserFavoriteQuestionsViewModel>(dbEntity, mediaConverter, dbTags, dbFirstPhotos, dbSecondPhotos, backgroundSizeType);
return(viewModel);
}
public async Task <List <string> > GetStandardBackgroundsUrl(BackgroundSizeType backgroundSize)
{
try
{
_logger.LogInformation($"{nameof(MediaServerConnection)}.{nameof(GetStandardBackgroundsUrl)}.Start");
var body = JsonConvert.SerializeObject(new { size = (int)backgroundSize });
var result = (await MediaServerConnect(_standardBackgroundUrl, body)).Urls;
_logger.LogInformation($"{nameof(MediaServerConnection)}.{nameof(GetStandardBackgroundsUrl)}.End");
return(result);
}
catch (Exception ex)
{
_logger.LogError(ex, $"{nameof(MediaServerConnection)}.{nameof(GetStandardBackgroundsUrl)}");
}
return(new List <string>());
}
private List <NewsAnsweredQuestionViewModel> GetNewsAnsweredQuestionsAsync(TwoButtonsContext context, int userId,
BackgroundSizeType backgroundSizeType)
{
var userAnsweredQuestions = MainDb.News.GetNewsAnsweredQuestions(context, userId);
//return new List<NewsAnsweredQuestionViewModel>();
var result = new List <NewsAnsweredQuestionViewModel>();
foreach (var question in userAnsweredQuestions)
{
GetTagsAndPhotos(context, userId, question.NewsAnsweredQuestionDb.QuestionId, out var tags, out var firstPhotos,
out var secondPhotos);
var resultQuestion =
question.MapToNewsAnsweredQuestionsViewModel(MediaConverter, tags, firstPhotos, secondPhotos,
backgroundSizeType);
result.Add(resultQuestion);
}
return(result);
}
public List <string> GetStandardBackgroundUrls(BackgroundSizeType size)
{
var relativeFolder = "";
switch (size)
{
case BackgroundSizeType.Original:
relativeFolder = _folderConfiguration.Backgrounds.Standards.Originals.GetFullHashPath();
break;
case BackgroundSizeType.Mobile:
relativeFolder = _folderConfiguration.Backgrounds.Standards.Mobiles.GetFullHashPath();
break;
}
var pcPath = Path.Combine(_fileManager.GetAbsoluteMediaRootPath(), relativeFolder);
return(Directory.GetFiles(pcPath)
.Select(x => _fileManager.ChangePcPathToWeb(Path.Combine(relativeFolder, Path.GetFileName(x)))).ToList());
}
public List <string> GetStandardBackgroundUrls(BackgroundSizeType size)
{
_logger.LogInformation($"{nameof(MediaService)}.{nameof(GetStandardBackgroundUrls)}.Start");
var relativeFolder = "";
switch (size)
{
case BackgroundSizeType.Original:
relativeFolder = _folderConfiguration.Backgrounds.Standards.Originals.GetFullHashPath();
break;
case BackgroundSizeType.Mobile:
relativeFolder = _folderConfiguration.Backgrounds.Standards.Mobiles.GetFullHashPath();
break;
}
var pcPath = Path.Combine(_fileManager.GetAbsoluteMediaRootPath(), relativeFolder);
var result = Directory.GetFiles(pcPath)
.Select(x => _fileManager.ChangePcPathToWeb(Path.Combine(relativeFolder, Path.GetFileName(x)))).ToList();
_logger.LogInformation($"{nameof(MediaService)}.{nameof(GetStandardBackgroundUrls)}.End");
return(result);
}
public string CreateRelativeBackgroundPath(string imageName, BackgroundType backgroundType, BackgroundSizeType size)
{
_logger.LogInformation($"{nameof(MediaService)}.{nameof(CreateRelativeBackgroundPath)}.Start");
BackgroundSizeFolders backgroundSizeFolders;
switch (backgroundType)
{
case BackgroundType.Standard:
backgroundSizeFolders = _folderConfiguration.Backgrounds.Standards;
break;
case BackgroundType.Custom:
default:
backgroundSizeFolders = _folderConfiguration.Backgrounds.Customs;
break;
}
var name = Path.GetFileNameWithoutExtension(imageName);
var ext = Path.GetExtension(imageName);
var relativeFolder = "";
switch (size)
{
case BackgroundSizeType.Original:
relativeFolder = backgroundSizeFolders.Originals.GetFullHashPath();
break;
case BackgroundSizeType.Mobile:
relativeFolder = backgroundSizeFolders.Mobiles.GetFullHashPath();
break;
}
var result = Path.Combine(relativeFolder, name + $"_{size.ToString().ToLower()}" + ext);
_logger.LogInformation($"{nameof(MediaService)}.{nameof(CreateRelativeBackgroundPath)}.End");
return(result);
}
public static NewsFavoriteQuestionViewModel MapToNewsFavoriteQuestionsViewModel(this NewsFavoriteQuestionDto dto, MediaConverter mediaConverter,
IEnumerable <TagDb> dbTags, IEnumerable <PhotoDb> dbFirstPhotos, IEnumerable <PhotoDb> dbSecondPhotos, BackgroundSizeType backgroundSizeType)
{
var viewModel =
QuestionDbToViewModel <NewsFavoriteQuestionViewModel>(dto.NewsFavoriteQuestionDb, mediaConverter, dbTags, dbFirstPhotos,
dbSecondPhotos, backgroundSizeType);
viewModel.FavoriteAddedUser = new NewsUserViewModel
{
UserId = dto.NewsFavoriteQuestionDb.FavoriteAddedUserId,
SexType = dto.NewsFavoriteQuestionDb.FavoriteAddedUserSexType,
Login = dto.NewsFavoriteQuestionDb.FavoriteAddedUserFirstName + " " + dto.NewsFavoriteQuestionDb.FavoriteAddedUserLastName
};
viewModel.Priority = dto.Priority;
viewModel.NewsType = CommonLibraries.NewsType.Favorite;
return(viewModel);
}
public static NewsAskedQuestionViewModel MapToNewsAskedQuestionsViewModel(this NewsAskedQuestionDto dto, MediaConverter mediaConverter,
IEnumerable <TagDb> dbTags, IEnumerable <PhotoDb> dbFirstPhotos, IEnumerable <PhotoDb> dbSecondPhotos, BackgroundSizeType backgroundSizeType)
{
var viewModel =
QuestionDbToViewModel <NewsAskedQuestionViewModel>(dto.NewsAskedQuestionDb, mediaConverter, dbTags, dbFirstPhotos,
dbSecondPhotos, backgroundSizeType);
viewModel.Priority = dto.Priority;
viewModel.NewsType = CommonLibraries.NewsType.Asked;
return(viewModel);
}
public string CreateRelativeBackgroundPath(string imageName, BackgroundType backgroundType, BackgroundSizeType size)
{
BackgroundSizeFolders backgroundSizeFolders;
switch (backgroundType)
{
case BackgroundType.Standard:
backgroundSizeFolders = _folderConfiguration.Backgrounds.Standards;
break;
case BackgroundType.Custom:
default:
backgroundSizeFolders = _folderConfiguration.Backgrounds.Customs;
break;
}
var name = Path.GetFileNameWithoutExtension(imageName);
var ext = Path.GetExtension(imageName);
var relativeFolder = "";
switch (size)
{
case BackgroundSizeType.Original:
relativeFolder = backgroundSizeFolders.Originals.GetFullHashPath();
break;
case BackgroundSizeType.Mobile:
relativeFolder = backgroundSizeFolders.Mobiles.GetFullHashPath();
break;
}
return(Path.Combine(relativeFolder, name + $"_{size.ToString().ToLower()}" + ext));
}
public static GetQuestionViewModel MapToGetQuestionsViewModel(this QuestionDb dbEntity, MediaConverter mediaConverter, IEnumerable <TagDb> dbTags,
IEnumerable <PhotoDb> dbFirstPhotos, IEnumerable <PhotoDb> dbSecondPhotos, IEnumerable <CommentDb> comments, BackgroundSizeType backgroundSizeType)
{
var viewModel = QuestionDbToViewModel <GetQuestionViewModel>(dbEntity, mediaConverter, dbTags, dbFirstPhotos, dbSecondPhotos, backgroundSizeType);
viewModel.Comments = comments.MapCommentsDbToViewModel(mediaConverter);
return(viewModel);
}
public static RecommendedQuestionViewModel MapToRecommendedQuestionsViewModel(this RecommendedQuestionDto dbEntity, MediaConverter mediaConverter,
IEnumerable <TagDb> dbTags, IEnumerable <PhotoDb> dbFirstPhotos, IEnumerable <PhotoDb> dbSecondPhotos, BackgroundSizeType backgroundSizeType)
{
var viewModel =
QuestionDbToViewModel <RecommendedQuestionViewModel>(dbEntity, mediaConverter, dbTags, dbFirstPhotos, dbSecondPhotos, backgroundSizeType);
viewModel.Users = dbEntity.RecommendedToUsers;
return(viewModel);
}
public static TopQuestionsViewModel MapToTopQuestionsViewModelMod(this QuestionDto dbEntity, MediaConverter mediaConverter,
IEnumerable <TagDb> dbTags, IEnumerable <PhotoDb> dbFirstPhotos, IEnumerable <PhotoDb> dbSecondPhotos, BackgroundSizeType backgroundSizeType)
{
var viewModel = new TopQuestionsViewModel
{
QuestionId = dbEntity.QuestionId,
Condition = dbEntity.Condition,
Options = dbEntity.Options.Select(x => new Option {
Text = x.Text, Voters = x.Voters
}).ToList(),
Author = new AuthorViewModel
{
UserId = dbEntity.Author.UserId,
Login = dbEntity.Author.FirstName + " " + dbEntity.Author.LastName,
SexType = dbEntity.Author.SexType,
SmallAvatarUrl = mediaConverter.ToFullAvatarUrl(dbEntity.Author.OriginalAvatarUrl, AvatarSizeType.Small)
},
BackgroundUrl = mediaConverter.ToFullBackgroundurlUrl(dbEntity.OriginalBackgroundUrl, backgroundSizeType),
QuestionType = dbEntity.QuestionType,
QuestionAddDate = dbEntity.AddedDate,
LikesCount = dbEntity.LikesCount,
DislikesCount = dbEntity.DislikesCount,
YourAnswerType = dbEntity.YourAnswerType,
YourFeedbackType = dbEntity.YourFeedbackType,
IsFavorite = dbEntity.IsFavorite,
IsSaved = dbEntity.IsSaved,
CommentsCount = dbEntity.CommentsCount,
Photos = new List <List <PhotoViewModel> > {
MapPhotosDbToViewModel(dbFirstPhotos, mediaConverter),
MapPhotosDbToViewModel(dbSecondPhotos, mediaConverter)
},
Tags = MapTagsDbToTagViewModel(dbTags)
// FirstOption = dbEntity.Options.FirstOrDefault(x=>x.)
};
return(viewModel);
}
public void CopyBackgrounds(string sourceFolder, BackgroundType backgroundType, BackgroundSizeType copyToNewSize)
{
_logger.LogInformation($"{nameof(MediaService)}.{nameof(CopyBackgrounds)}.Start");
if (string.IsNullOrEmpty(sourceFolder))
{
throw new Exception("SourceUrl is null or empty");
}
var fullSourcePath = Path.Combine(_fileManager.GetAbsoluteMediaRootPath(), sourceFolder);
var fullNewPath = Path.Combine(_fileManager.GetAbsoluteMediaRootPath(),
CreateBackgroundPath(backgroundType, copyToNewSize));
Size size;
switch (copyToNewSize)
{
case BackgroundSizeType.Original:
size = null;
break;
case BackgroundSizeType.Mobile:
size = new MobileBackgroundSizeFolder(null).Size;
break;
default: throw new Exception("Such BackgrodunSizeType does not exist.");
}
var files = Directory.GetFiles(fullSourcePath);
foreach (var file in files)
{
var fileName = Path.GetFileNameWithoutExtension(file);
var ext = Path.GetExtension(file);
if (fileName.Contains("original"))
{
fileName = fileName.Replace("original", copyToNewSize.ToString().ToLower());
}
else
{
fileName = Guid.NewGuid().ToString().Replace("-", "").Substring(0, 10) + "_" +
copyToNewSize.ToString().ToLower();
}
var fullNewFilePath = Path.Combine(fullNewPath, fileName + ext);
if (!File.Exists(fullNewFilePath))
{
if (size == null)
{
CopyFile(file, fullNewFilePath);
}
else
{
ResizeImage(file, fullNewFilePath, size.Height, size.Width);
}
}
}
_logger.LogInformation($"{nameof(MediaService)}.{nameof(CopyBackgrounds)}.End");
}
private string CreateBackgroundPath(BackgroundType backgroundType, BackgroundSizeType copyToNewSize)
{
return(Path.Combine(GetHashFolderName("Background"), GetHashFolderName(backgroundType.ToString()),
GetHashFolderName(copyToNewSize.ToString())));
}
public static T QuestionDbToViewModel <T>(this QuestionBaseDb dbEntity, MediaConverter mediaConverter, IEnumerable <TagDb> dbTags,
IEnumerable <PhotoDb> dbFirstPhotos, IEnumerable <PhotoDb> dbSecondPhotos, BackgroundSizeType backgroundSizeType) where T : QuestionBaseViewModel, new()
{
var question = new T
{
QuestionId = dbEntity.QuestionId,
Condition = dbEntity.Condition,
Options =
new List <Option>
{
new Option(dbEntity.FirstAnswersCount, dbEntity.FirstOption),
new Option(dbEntity.SecondAnswersCount, dbEntity.SecondOption)
},
BackgroundUrl = dbEntity.OriginalBackgroundUrl != null?mediaConverter.ToFullBackgroundurlUrl(dbEntity.OriginalBackgroundUrl, backgroundSizeType) : null,
QuestionType = dbEntity.QuestionType,
QuestionAddDate = dbEntity.AddedDate,
Author = new AuthorViewModel
{
UserId = dbEntity.UserId,
Login = dbEntity.FirstName + " " + dbEntity.LastName,
SexType = dbEntity.SexType,
SmallAvatarUrl = dbEntity.OriginalAvatarUrl != null?mediaConverter.ToFullAvatarUrl(dbEntity.OriginalAvatarUrl, AvatarSizeType.Small) : null
},
LikesCount = dbEntity.LikesCount,
DislikesCount = dbEntity.DislikesCount,
YourFeedbackType = dbEntity.YourFeedbackType,
YourAnswerType = dbEntity.YourAnswerType,
IsFavorite = dbEntity.IsFavorite,
IsSaved = dbEntity.IsSaved,
CommentsCount = dbEntity.CommentsCount,
Tags = dbTags.MapTagsDbToTagViewModel(),
Photos = new List <List <PhotoViewModel> >()
{
dbFirstPhotos.MapPhotosDbToViewModel(mediaConverter), dbSecondPhotos.MapPhotosDbToViewModel(mediaConverter)
}
};
return(question);
}
