public async Task <bool> PushRecommendedQuestionsNotification(
RecommendedQuestionNotification recommendedQuestionNotification)
{
Logger.LogInformation($"{nameof(NotificationsMessageService)}.{nameof(PushRecommendedQuestionsNotification)}.Start");
var info = await Db.UsersInfo.FindUserInfoAsync(recommendedQuestionNotification.NotifierId);
if (info == null)
{
return(false);
}
var notification = new Notification
{
UserId = recommendedQuestionNotification.NotifierId,
Login = info.FirstName + " " + info.LastName,
SmallAvatarLink = MediaConverter.ToFullAvatarUrl(info.OriginalAvatarUrl, AvatarSizeType.Small),
ActionType = ActionType.Follow,
EmmiterId = recommendedQuestionNotification.QuestionId,
ActionDate = recommendedQuestionNotification.RecommendedDate
};
await PushNotification(recommendedQuestionNotification.UserToId, notification);
Logger.LogInformation($"{nameof(NotificationsMessageService)}.{nameof(PushRecommendedQuestionsNotification)}.End");
return(true);
}
public CommonAuthService(IJwtService jwtService, AuthorizationUnitOfWork db, ILogger <CommonAuthService> logger, MediaConverter mediaConverter)
{
Db = db;
JwtService = jwtService;
Logger = logger;
MediaConverter = mediaConverter;
}
private static async Task <bool> SendSegmentAsync(string fileName, IOwinContext context, StreamItem streamItem)
{
if (!string.IsNullOrEmpty(fileName) && streamItem.StreamContext is TranscodeContext tc)
{
using (await streamItem.RequestBusyLockAsync(SendDataCancellation.Token))
{
var segment = await MediaConverter.GetSegmentFileAsync((VideoTranscoding)streamItem.TranscoderObject.TranscodingParameter, tc, fileName);
if (segment != null)
{
if (segment.Value.ContainerEnum is VideoContainer)
{
VideoTranscoding video = (VideoTranscoding)streamItem.TranscoderObject.TranscodingParameter;
List <string> profiles = ProfileMime.ResolveVideoProfile((VideoContainer)segment.Value.ContainerEnum, video.TargetVideoCodec, video.TargetAudioCodec, EncodingProfile.Unknown, 0, 0, 0, 0, 0, 0, Timestamp.None);
string mime = "video/unknown";
ProfileMime.FindCompatibleMime(streamItem.Profile, profiles, ref mime);
context.Response.ContentType = mime;
}
else if (segment.Value.ContainerEnum is SubtitleCodec)
{
context.Response.ContentType = SubtitleHelper.GetSubtitleMime((SubtitleCodec)segment.Value.ContainerEnum);
}
bool onlyHeaders = context.Request.Method == "HEAD" || context.Response.StatusCode == (int)HttpStatusCode.NotModified;
Logger.Debug("RetrieveStream: Sending file header only: {0}", onlyHeaders.ToString());
await SendWholeFileAsync(context, segment.Value.FileData, onlyHeaders);
// Close the Stream so that FFMpeg can replace the playlist file
segment.Value.FileData.Dispose();
return(true);
}
}
}
return(false);
}
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 void StopTranscoding()
{
if (TranscodingParameter != null)
{
MediaConverter.StopTranscodeAsync(_clientId, TranscodingParameter.TranscodeId);
}
}
public static UserInfoViewModel MapToUserInfoViewModel(
this UserInfoDto dbEntity, MediaConverter mediaConverter)
{
var viewModel = new UserInfoViewModel
{
UserId = dbEntity.UserId,
Login = dbEntity.FirstName + " " + dbEntity.LastName,
Age = dbEntity.BirthDate.Age(),
SexType = dbEntity.SexType,
City = dbEntity.City,
Description = dbEntity.Description,
LargeAvatarUrl = mediaConverter.ToFullAvatarUrl(dbEntity.OriginalAvatarUrl, AvatarSizeType.Large),
SmallAvatarUrl = mediaConverter.ToFullAvatarUrl(dbEntity.OriginalAvatarUrl, AvatarSizeType.Small),
IsYouFollowed = dbEntity.IsYouFollowed,
IsHeFollowed = dbEntity.IsHeFollowed,
AskedQuestionsCount = dbEntity.AskedQuestionsCount,
AnswersCount = dbEntity.AnswersCount,
FollowersCount = dbEntity.FollowersCount,
FollowedCount = dbEntity.FollowingsCount,
FavoritesCount = dbEntity.FavoritesCount,
CommentsCount = dbEntity.CommentsCount,
};
return(viewModel);
}
public IActionResult Post([ModelBinder(BinderType = typeof(JsonModelBinder))] RequestMediaJsonModel JsonModel, List <IFormFile> Images)
{
ResponseModel <List <ResponseModel <MediaFile> > > vResult;
try
{
var workWithFiles = new MediaConverter(JsonModel.Base64Files, JsonModel.FileUrlList, Images).DownloadAndCreatePreview();
if (!workWithFiles.IsOk)
{
throw new CustomException(workWithFiles.Code, workWithFiles.Message);
}
vResult = workWithFiles;
}
catch (CustomException ce)
{
return(BadRequest(ce.Message));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(Ok(vResult));
}
public async Task <bool> CommentNotification(CommentNotification commentNotification)
{
Logger.LogInformation($"{nameof(NotificationsMessageService)}.{nameof(CommentNotification)}.Start");
var info = await Db.UsersInfo.FindUserInfoAsync(commentNotification.NotifierId);
if (info == null)
{
return(false);
}
var sendToId = await Db.Notifications.GetUserIdForComment(commentNotification.CommentId);
if (sendToId <= 0)
{
return(false);
}
var notification = new Notification
{
UserId = commentNotification.NotifierId,
Login = info.FirstName + " " + info.LastName,
SmallAvatarLink = MediaConverter.ToFullAvatarUrl(info.OriginalAvatarUrl, AvatarSizeType.Small),
ActionType = ActionType.Follow,
EmmiterId = commentNotification.CommentId,
ActionDate = commentNotification.CommentedDate
};
await PushNotification(sendToId, notification);
Logger.LogInformation($"{nameof(NotificationsMessageService)}.{nameof(CommentNotification)}.End");
return(true);
}
public void StopTranscoding()
{
if (TranscodingParameter != null)
{
MediaConverter.StopTranscodeAsync(Client.ClientId.ToString(), TranscodingParameter.TranscodeId).Wait();
}
}
public NotificationsMessageService(ConnectionsHub hub, NotificationsDataUnitOfWork db, NotificationManager notificationManager, ILogger <NotificationsMessageService> logger, MediaConverter mediaConverter)
{
Db = db;
Hub = hub;
NotificationManager = notificationManager;
Logger = logger;
MediaConverter = mediaConverter;
}
public CommentsController(QuestionsUnitOfWork mainDb, ConnectionsHub hub, ILogger <ComplaintsController> logger,
MediaConverter mediaConverter)
{
MainDb = mainDb;
Hub = hub;
Logger = logger;
MediaConverter = mediaConverter;
}
public QuestionsController(QuestionsUnitOfWork mainDb, ILogger <QuestionsController> logger, ConnectionsHub hub,
MediaConverter mediaConverter)
{
MainDb = mainDb;
Logger = logger;
Hub = hub;
MediaConverter = mediaConverter;
}
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 NewsQuestionsController(QuestionsUnitOfWork mainDb, DbContextOptions <TwoButtonsContext> dbOptions,
ConnectionsHub hub, ILogger <NewsQuestionsController> logger, MediaConverter mediaConverter)
{
MainDb = mainDb;
DbOptions = dbOptions;
Hub = hub;
Logger = logger;
MediaConverter = mediaConverter;
}
public ExternalAuthService(AuthorizationUnitOfWork db, ConnectionsHub hub, IVkService vkService,
IFbService fbService, ILogger <ExternalAuthService> logger, MediaConverter mediaConverter)
{
Db = db;
Hub = hub;
VkService = vkService;
FbService = fbService;
Logger = logger;
MediaConverter = mediaConverter;
}
protected virtual void OnChanged()
{
if (Text == null || Icon == null)
{
return;
}
textNode.Text = Text;
imageNode.Source = MediaConverter.ImageSourceFromBitmap(MediaConverter.GetBitmapByName(Icon));
}
public FriendsService(IOptions <FacebookAuthSettings> fbAuthSettingsAccessor,
IOptions <VkAuthSettings> vkAuthSettingsAccessor, IOptions <JwtSettings> jwtOptions,
SocialDataUnitOfWork socialDb, ILogger <FriendsService> logger, MediaConverter mediaConverter)
{
FbAuthSettings = fbAuthSettingsAccessor.Value;
VkAuthSettings = vkAuthSettingsAccessor.Value;
Logger = logger;
SocialDb = socialDb;
MediaConverter = mediaConverter;
}
public MainWindow()
{
Icon = MediaConverter.ImageSourceFromBitmap(Properties.Resources.Fire.ToBitmap());
InitializeComponent();
nvFrom.OnFormSubmit += NvFrom_OnFormSubmit;
core.RunWorkerCompleted += Core_RunWorkerCompleted;
SetupLog();
}
public AccountService(AccountDataUnitOfWork accountDb, ConnectionsHub hub, IVkService vkService,
IFbService fbService, ILogger <AccountService> logger, MediaConverter mediaConverter)
{
Db = accountDb;
Hub = hub;
VkService = vkService;
FbService = fbService;
Logger = logger;
MediaConverter = mediaConverter;
}
public PreviewRecordingJob(DatabaseContext context,
IConfiguration config,
IHubContext <MessageHub> hub,
ChromaKeyParamGuesser chromaKeyParamGuesser,
MediaConverter converter)
{
this._context = context;
this._config = config;
this.hub = hub;
this.chromaKeyParamGuesser = chromaKeyParamGuesser;
this.converter = converter;
}
public MediaManager(string ffmpegExecutablePath, string mp4boxExecutablePath, string host, string username, string password, int port)
{
this.converter = new MediaConverter(ffmpegExecutablePath, mp4boxExecutablePath);
this.deployer = new SFTPMediaDeployer(host, username, password, port);
// Converter Events
this.ConvertionDone += this.converter.ConvertionDone;
this.OutputReceived += this.converter.OutputReceived;
this.ErrorReceived += this.converter.ErrorReceived;
// Deployer Callback
this.deployer.ProgressStatus = this.ProgressStatus;
}
/// <summary>
/// Does the preparation to start a transcode stream
/// </summary>
internal static async Task <TranscodeContext> StartTranscodeStreamingAsync(EndPointSettings client, double startTime, double lengthTime, StreamItem newStreamItem)
{
if (STREAM_ITEMS.TryAdd(client.ClientId, newStreamItem))
{
await newStreamItem.BusyLock.WaitAsync();
try
{
if (newStreamItem?.TranscoderObject?.TranscodingParameter == null)
{
STREAM_ITEMS.TryRemove(client.ClientId, out _);
return(null);
}
if (!newStreamItem.TranscoderObject.StartTrancoding())
{
Logger.Debug("StreamControl: Transcoding busy for mediaitem {0}", newStreamItem.RequestedMediaItem);
return(null);
}
if (newStreamItem.IsLive)
{
newStreamItem.StreamContext = await MediaConverter.GetLiveStreamAsync(client.ClientId.ToString(), newStreamItem.TranscoderObject.TranscodingParameter, newStreamItem.LiveChannelId, true);
}
else
{
newStreamItem.StreamContext = await MediaConverter.GetMediaStreamAsync(client.ClientId.ToString(), newStreamItem.TranscoderObject.TranscodingParameter, startTime, lengthTime, true);
}
if (newStreamItem.StreamContext is TranscodeContext context)
{
context.UpdateStreamUse(true);
return(context);
}
else if (newStreamItem.StreamContext != null)
{
//We want a transcoded stream
newStreamItem.StreamContext.Dispose();
newStreamItem.StreamContext = null;
}
return(null);
}
finally
{
newStreamItem.BusyLock.Release();
}
}
return(null);
}
//public int UserId { get; set; }
//public string Login { get; set; }
//public int Age { get; set; }
//public SexType SexType { get; set; }
//public string Description { get; set; }
//public string SmallAvatarUrl { get; set; }
//public string LargeAvatarUrl { get; set; }
//public bool IsYouFollowed { get; set; }
//public bool IsHeFollowed { get; set; }
//public int AskedQuestionsCount { get; set; }
//public int AnswersCount { get; set; }
//public int FollowersCount { get; set; }
//public int FollowedCount { get; set; }
//public int FavoritesCount { get; set; }
//public int CommentsCount { get; set; }
//public UserStatisticsViewModel UserStatistics { get; set; } = new UserStatisticsViewModel();
//public List<UserContactsViewModel> Social { get; set; } = new List<UserContactsViewModel>();
public static UserInfoViewModel CreateFromUserInfoDb(UserInfoDto userInfo, MediaConverter mediaConverter)
{
return(new UserInfoViewModel
{
BirthDate = userInfo.BirthDate,
City = userInfo.City,
Description = userInfo.Description,
LargeAvatarUrl = mediaConverter.ToFullAvatarUrl(userInfo.OriginalAvatarUrl, AvatarSizeType.Large),
SmallAvatarUrl = mediaConverter.ToFullAvatarUrl(userInfo.OriginalAvatarUrl, AvatarSizeType.Small),
Login = userInfo.FirstName + " " + userInfo.LastName,
SexType = userInfo.SexType,
UserId = userInfo.UserId
});
}
public static List <AnsweredListViewModel> MapAnsweredListDbToViewModel(
this IEnumerable <AnsweredListDb> answeredList, MediaConverter mediaConverter)
{
return(answeredList.Select(v => new AnsweredListViewModel
{
UserId = v.UserId,
Login = v.FirstName + " " + v.LastName,
SmallAvatarUrl = mediaConverter.ToFullAvatarUrl(v.OriginalAvatarUrl, AvatarSizeType.Small),
Age = v.BirthDate.Age(),
SexType = v.SexType,
IsHeFollowed = v.IsHeFollowed,
IsYouFollowed = v.IsYouFollowed
}).ToList());
}
public void IsConvertingToMp3()
{
MediaDownloader downloader = new MediaDownloader();
MediaFile mediaFile = MediaFile.CreateNew(VboxDownloadConvertTests.VboxDownloadVideo);
string existingPath = Path.Combine(Directory.GetCurrentDirectory(), mediaFile.Metadata.FileName + mediaFile.Metadata.FileExtension);
if (!File.Exists(existingPath))
{
downloader.Download(mediaFile, Directory.GetCurrentDirectory());
}
MediaConverter converter = new MediaConverter();
ConvertResult result = converter.Convert(mediaFile, existingPath, Directory.GetCurrentDirectory(), new MediaConverterMetadata(Bitrates.Kbps192));
Assert.IsTrue(result.IsConverted);
Assert.IsTrue(File.Exists(result.ConvertedPath));
}
/// <summary>
/// Does the preparation to start a stream
/// </summary>
internal static async Task <StreamContext> StartOriginalFileStreamingAsync(string identifier)
{
if (STREAM_ITEMS.TryGetValue(identifier, out var currentStreamItem))
{
using (await currentStreamItem.RequestBusyLockAsync())
{
if (currentStreamItem.IsActive)
{
currentStreamItem.TranscoderObject?.StopStreaming();
if (currentStreamItem.StreamContext is TranscodeContext context)
{
context.UpdateStreamUse(false);
}
else if (currentStreamItem.StreamContext != null)
{
currentStreamItem.StreamContext.Dispose();
currentStreamItem.StreamContext = null;
}
}
IMediaAccessor mediaAccessor = ServiceRegistration.Get <IMediaAccessor>();
List <IResourceAccessor> resources = new List <IResourceAccessor>();
foreach (var res in currentStreamItem.TranscoderObject.Metadata.FilePaths)
{
var path = ResourcePath.Deserialize(res.Value);
if (mediaAccessor.LocalResourceProviders.TryGetValue(path.BasePathSegment.ProviderId, out var resourceProvider) &&
resourceProvider is IBaseResourceProvider baseProvider && baseProvider.TryCreateResourceAccessor(res.Value, out var accessor))
{
using (accessor)
{
if (accessor is IFileSystemResourceAccessor)
{
currentStreamItem.TranscoderObject.StartStreaming();
currentStreamItem.StreamContext = await MediaConverter.GetFileStreamAsync(path);
return(currentStreamItem.StreamContext);
}
}
}
}
}
}
return(null);
}
public void ConversionEndedEventTest()
{
MediaDownloader downloader = new MediaDownloader();
MediaFile file = MediaFile.CreateNew(VboxDownloadVideo);
string downloadedPath = downloader.Download(file, Environment.GetFolderPath(Environment.SpecialFolder.Desktop)).DownloadPath;
bool converting = false;
MediaConverter converter = new MediaConverter();
converter.MediaFileConvertionCompelete += delegate { converting = true; };
converter.Convert(file, downloadedPath, Environment.GetFolderPath(Environment.SpecialFolder.Desktop), new MediaConverterMetadata
{
AudioBitrate = Bitrates.Kbps192,
Extension = SupportedConversionFormats.Mp3,
FileName = file.Metadata.FileName
});
Assert.AreEqual(true, converting);
}
private async Task ConvertFiles()
{
IsConversionInProgress = true;
StartConversionCommand.RaiseCanExecuteChanged();
BrowseTargetFolderCommand.RaiseCanExecuteChanged();
if (!Directory.Exists(TargetFolderPath))
{
Directory.CreateDirectory(TargetFolderPath);
}
var converter = new MediaConverter(TargetFolderPath);
await converter.ConvertFiles(InputItems.Select((item) => item.FilePath).ToArray());
InputItems.Clear();
IsConversionInProgress = false;
StartConversionCommand.RaiseCanExecuteChanged();
BrowseTargetFolderCommand.RaiseCanExecuteChanged();
}
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);
}
private async void HandleFileConversion(string filepath)
{
//Path.get
string filename = Path.GetFileNameWithoutExtension(filepath);
var job = new ConversionItem
{
Title = filename,
};
ConversionJobs.Add(job);
ConversionJobsListView.ScrollIntoView(job);
// Convert
job.Status = ConversionJobStatus.Converting;
filename = MediaConverter.RemoveInvalidFilenameCharacters(filename);
string dstFilepath = MediaConverter.EnsureUniqueFilepath($"{Settings.OutputFolder}\\{filename}.wav");
await MediaConverter.FFmpegConvertToWavAsync(filepath, dstFilepath, Settings.OutputFrequency, Settings.OutputVolumeMultiplier);
// Finish
job.Status = ConversionJobStatus.Done;
}
