Beispiel #1
0
        public Task ChangeItem(ChangeItemData data)
        {
            if (data.ChangeType == ChangeItemType.RemoveCompleted)
            {
                var waits = new List <Task>();
                RemoveCompleted(waits);
                return(Task.WhenAll(waits));
            }

            // アイテム操作
            var target = Queue.FirstOrDefault(s => s.Id == data.ItemId);

            if (target == null)
            {
                return(server.NotifyError(
                           "指定されたアイテムが見つかりません", false));
            }

            if (data.ChangeType == ChangeItemType.ResetState ||
                data.ChangeType == ChangeItemType.UpdateProfile ||
                data.ChangeType == ChangeItemType.Duplicate)
            {
                if (target.State == QueueState.PreFailed)
                {
                    return(server.NotifyError("このアイテムは追加処理に失敗しているため操作できません", false));
                }
                if (data.ChangeType == ChangeItemType.ResetState)
                {
                    // エンコード中は変更できない
                    if (target.State == QueueState.Encoding)
                    {
                        return(server.NotifyError("エンコード中のアイテムはリトライできません", false));
                    }
                }
                else if (data.ChangeType == ChangeItemType.UpdateProfile)
                {
                    // エンコード中は変更できない
                    if (target.State == QueueState.Encoding)
                    {
                        return(server.NotifyError("エンコード中のアイテムはプロファイル更新できません", false));
                    }
                }
                else if (data.ChangeType == ChangeItemType.Duplicate)
                {
                    // バッチモードでアクティブなやつは重複になるのでダメ
                    if (target.IsBatch && target.IsActive)
                    {
                        return(server.NotifyError("通常モードで追加されたアイテムは複製できません", false));
                    }
                }

                var waits = new List <Task>();

                if (target.IsBatch)
                {
                    // バッチモードでfailed/succeededフォルダに移動されていたら戻す
                    if (target.State == QueueState.Failed || target.State == QueueState.Complete)
                    {
                        if (Queue.Where(s => s.SrcPath == target.SrcPath).Any(s => s.IsActive) == false)
                        {
                            var dirPath  = Path.GetDirectoryName(target.SrcPath);
                            var movedDir = (target.State == QueueState.Failed) ?
                                           ServerSupport.FAIL_DIR :
                                           ServerSupport.SUCCESS_DIR;
                            var movedPath = dirPath + "\\" + movedDir + "\\" + Path.GetFileName(target.SrcPath);
                            if (File.Exists(movedPath))
                            {
                                // EDCB関連ファイルも移動したかどうかは分からないが、あれば戻す
                                try
                                {
                                    ServerSupport.MoveTSFile(movedPath, dirPath, true);
                                }
                                catch (Exception e)
                                {
                                    return(server.FatalError(
                                               "ファイルの移動に失敗しました", e));
                                }
                            }
                        }
                    }
                }

                if (data.ChangeType == ChangeItemType.ResetState)
                {
                    // リトライはプロファイル再適用も行う
                    UpdateProfileItem(target, waits);
                    ResetStateItem(target, waits);
                    waits.Add(server.NotifyMessage("リトライします", false));
                }
                else if (data.ChangeType == ChangeItemType.UpdateProfile)
                {
                    if (UpdateProfileItem(target, waits))
                    {
                        waits.Add(server.NotifyMessage("新しいプロファイルが適用されました", false));
                    }
                    else
                    {
                        waits.Add(server.NotifyMessage("すでに最新のプロファイルが適用されています", false));
                    }
                }
                else
                {
                    DuplicateItem(target, waits);
                    waits.Add(server.NotifyMessage("複製しました", false));
                }

                return(Task.WhenAll(waits));
            }
            else if (data.ChangeType == ChangeItemType.Cancel)
            {
                if (server.CancelItem(target) || target.IsActive)
                {
                    target.State = QueueState.Canceled;
                    return(Task.WhenAll(
                               ClientQueueUpdate(new QueueUpdate()
                    {
                        Type = UpdateType.Update,
                        Item = target
                    }),
                               server.NotifyMessage("キャンセルしました", false)));
                }
                else
                {
                    return(server.NotifyError(
                               "このアイテムはアクティブ状態でないため、キャンセルできません", false));
                }
            }
            else if (data.ChangeType == ChangeItemType.Priority)
            {
                target.Priority = data.Priority;
                server.ReScheduleQueue();
                return(Task.WhenAll(
                           ClientQueueUpdate(new QueueUpdate()
                {
                    Type = UpdateType.Update,
                    Item = target
                }),
                           server.NotifyMessage("優先度を変更しました", false)));
            }
            else if (data.ChangeType == ChangeItemType.Profile)
            {
                if (target.State == QueueState.Encoding)
                {
                    return(server.NotifyError("エンコード中はプロファイル変更できません", false));
                }
                if (target.State == QueueState.PreFailed)
                {
                    return(server.NotifyError("このアイテムはプロファイル変更できません", false));
                }

                var waits = new List <Task>();
                target.ProfileName = data.Profile;
                if (UpdateProfileItem(target, waits))
                {
                    waits.Add(server.NotifyMessage("プロファイルを「" + data.Profile + "」に変更しました", false));
                }
                else
                {
                    waits.Add(server.NotifyMessage("既に同じプロファイルが適用されています", false));
                }

                return(Task.WhenAll(waits));
            }
            else if (data.ChangeType == ChangeItemType.RemoveItem)
            {
                server.CancelItem(target);
                target.State = QueueState.Canceled;
                Queue.Remove(target);
                UpdateQueueOrder();
                return(Task.WhenAll(
                           ClientQueueUpdate(new QueueUpdate()
                {
                    Type = UpdateType.Remove,
                    Item = target
                }),
                           server.NotifyMessage("アイテムを削除しました", false)));
            }
            else if (data.ChangeType == ChangeItemType.ForceStart)
            {
                if (target.State != QueueState.Queue)
                {
                    return(server.NotifyError("待ち状態にないアイテムは開始できません", false));
                }
                else
                {
                    server.ForceStartItem(target);
                }
            }
            else if (data.ChangeType == ChangeItemType.RemoveSourceFile)
            {
                if (target.IsBatch == false)
                {
                    return(server.NotifyError("通常or自動追加以外はTSファイル削除ができません", false));
                }
                if (target.State != QueueState.Complete)
                {
                    return(server.NotifyError("完了していないアイテムはTSファイル削除ができません", false));
                }
                if (Queue.Where(s => s.SrcPath == target.SrcPath).Any(s => s.IsActive))
                {
                    return(server.NotifyError("まだ完了していない項目があるため、このTSは削除ができません", false));
                }

                // !!!削除!!!
                var dirPath   = Path.GetDirectoryName(target.SrcPath);
                var movedPath = dirPath + "\\" + ServerSupport.SUCCESS_DIR + "\\" + Path.GetFileName(target.SrcPath);
                if (File.Exists(movedPath))
                {
                    // EDCB関連ファイルも移動したかどうかは分からないが、あれば消す
                    try
                    {
                        ServerSupport.DeleteTSFile(movedPath, true);
                    }
                    catch (Exception e)
                    {
                        return(server.FatalError(
                                   "ファイルの削除に失敗しました", e));
                    }
                }

                // アイテム削除
                Queue.Remove(target);
                UpdateQueueOrder();
                return(Task.WhenAll(
                           ClientQueueUpdate(new QueueUpdate()
                {
                    Type = UpdateType.Remove,
                    Item = target
                }),
                           server.NotifyMessage("TSファイルを削除しました", false)));
            }
            else if (data.ChangeType == ChangeItemType.Move)
            {
                if (data.Position >= Queue.Count)
                {
                    return(server.NotifyError("位置が範囲外です", false));
                }

                Queue.Remove(target);
                Queue.Insert(data.Position, target);
                UpdateQueueOrder();
                return(Task.WhenAll(
                           ClientQueueUpdate(new QueueUpdate()
                {
                    Type = UpdateType.Move,
                    Item = target,
                    Position = data.Position
                })));
            }
            return(Task.FromResult(0));
        }
Beispiel #2
0
 public Task ChangeItem(ChangeItemData data)
 {
     return(Send(RPCMethodId.ChangeItem, data));
 }
Beispiel #3
0
 public Task ChangeItem(ChangeItemData data)
 {
     return(Server.ChangeItem(Copy(data)));
 }