public async Task <IActionResult> Save(ScenarioViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(await Edit(model));
            }

            var groupInfo = _userHelperService.GetSelectedGroup(User);

            Scenarios scenario = null;

            if (model.IdScenario.HasValue)
            {
                scenario = await _context.Scenarios.FirstOrDefaultAsync(x => x.Id == model.IdScenario.Value);
            }
            if (scenario == null)
            {
                scenario = new Scenarios
                {
                    IsEnabled = true,
                    IdGroup   = groupInfo.Key
                };
                await _context.Scenarios.AddAsync(scenario);
            }
            scenario.Action = model.Action;

            switch (model.Action)
            {
            case Models.Database.Common.ScenarioActions.Message:
            {
                scenario.IdChain  = null;
                scenario.IdChain2 = null;
                break;
            }

            case Models.Database.Common.ScenarioActions.AddToChain:
            {
                scenario.IdChain  = model.IdChain;
                scenario.IdChain2 = null;
                break;
            }

            case Models.Database.Common.ScenarioActions.RemoveFromChain:
            {
                scenario.IdChain  = null;
                scenario.IdChain2 = model.IdChain2;
                break;
            }

            case Models.Database.Common.ScenarioActions.ChangeChain:
            {
                scenario.IdChain  = model.IdChain;
                scenario.IdChain2 = model.IdChain2;
                break;
            }
            }

            scenario.InputMessage  = model.InputMessage;
            scenario.Name          = model.Name;
            scenario.IsStrictMatch = model.IsStrictMatch;

            if (model.Message?.HasMessage ?? false)
            {
                if (model.IdMessage.HasValue)
                {
                    var message = await _context.Messages
                                  .Include(x => x.Files)
                                  .FirstOrDefaultAsync(x => x.Id == model.IdMessage.Value);

                    message.Text         = model.Message.Message;
                    message.IsImageFirst = model.Message.IsImageFirst;

                    var keyboard = model.Message.GetVkKeyboard();
                    message.Keyboard = keyboard == null ? null : Newtonsoft.Json.JsonConvert.SerializeObject(keyboard);

                    if (model.Message.Files != null && model.Message.Files.Any())
                    {
                        IEnumerable <Guid> newIdFiles = model.Message.Files.Select(x => x.Id);
                        if (message.Files != null && message.Files.Any())
                        {
                            newIdFiles = newIdFiles.Except(message.Files.Select(x => x.IdFile));
                        }
                        DbHelper.AddFilesInMessage(_context, model.IdMessage.Value, newIdFiles);
                    }
                }
                else
                {
                    var message = await DbHelper.AddMessage(_context, groupInfo.Key, model.Message.Message, model.Message.GetVkKeyboard(), model.Message.IsImageFirst, model.Message.Files.Select(x => x.Id));

                    scenario.IdMessage = message.Id;
                }
            }
            else if (scenario.Message != null)
            {
                scenario.IdMessage = null;
                await DbHelper.RemoveMessage(_context, scenario.IdMessage.Value);
            }

            if (model.ErrorMessage?.HasMessage ?? false)
            {
                if (model.Action == Models.Database.Common.ScenarioActions.Message)
                {
                    await DbHelper.RemoveMessage(_context, scenario.IdErrorMessage.Value);

                    scenario.IdErrorMessage = null;
                }
                else if (model.IdErrorMessage.HasValue)
                {
                    var message = await _context.Messages
                                  .Include(x => x.Files)
                                  .FirstOrDefaultAsync(x => x.Id == model.IdErrorMessage.Value);

                    message.Text         = model.ErrorMessage.Message;
                    message.IsImageFirst = model.ErrorMessage.IsImageFirst;

                    var keyboard = model.ErrorMessage.GetVkKeyboard();
                    message.Keyboard = keyboard == null ? null : Newtonsoft.Json.JsonConvert.SerializeObject(keyboard);

                    if (model.Message.Files != null && model.Message.Files.Any())
                    {
                        IEnumerable <Guid> newIdFiles = model.Message.Files.Select(x => x.Id);
                        if (message.Files != null && message.Files.Any())
                        {
                            newIdFiles = newIdFiles.Except(message.Files.Select(x => x.IdFile));
                        }
                        DbHelper.AddFilesInMessage(_context, message.Id, newIdFiles);
                    }
                }
                else
                {
                    var message = await DbHelper.AddMessage(_context, groupInfo.Key, model.ErrorMessage.Message, model.ErrorMessage.GetVkKeyboard(), model.ErrorMessage.IsImageFirst, model.ErrorMessage.Files.Select(x => x.Id));

                    scenario.IdErrorMessage = message.Id;
                }
            }
            else if (scenario.ErrorMessage != null)
            {
                scenario.IdErrorMessage = null;
                await DbHelper.RemoveMessage(_context, scenario.IdErrorMessage.Value);
            }

            await _context.SaveChangesAsync();

            return(RedirectToAction(nameof(Index)));
        }
Beispiel #2
0
        public async Task <IActionResult> SaveMessage(EditMessageViewModel editMessageViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(await EditMessage(editMessageViewModel));
            }

            var groupInfo = _userHelperService.GetSelectedGroup(User);

            Messages message = null;

            if (editMessageViewModel.IdMessage.HasValue && await _context.Messages.AnyAsync(x => x.Id == editMessageViewModel.IdMessage.Value))
            {
                message = await _context.Messages.FirstOrDefaultAsync(x => x.Id == editMessageViewModel.IdMessage.Value);

                message.Text = editMessageViewModel.Message;

                var keyboard = editMessageViewModel.GetVkKeyboard();
                message.Keyboard = keyboard == null ? null : Newtonsoft.Json.JsonConvert.SerializeObject(keyboard);

                await _context.SaveChangesAsync();

                if (editMessageViewModel.Files != null && editMessageViewModel.Files.Any())
                {
                    IEnumerable <Guid> newIdFiles = editMessageViewModel.Files.Select(x => x.Id);
                    if (message.Files != null && message.Files.Any())
                    {
                        newIdFiles = newIdFiles.Except(message.Files.Select(x => x.IdFile));
                    }
                    DbHelper.AddFilesInMessage(_context, message.Id, newIdFiles);
                }
            }
            else
            {
                message = await DbHelper.AddMessage(_context, groupInfo.Key, editMessageViewModel.Message, editMessageViewModel.GetVkKeyboard(), editMessageViewModel.IsImageFirst, editMessageViewModel.Files.Select(x => x.Id));
            }

            ChainContents chainContent = null;

            if (editMessageViewModel.IdChainContent.HasValue)
            {
                chainContent = await _context.ChainContents.FirstOrDefaultAsync(x => x.Id == editMessageViewModel.IdChainContent.Value);
            }
            if (chainContent == null)
            {
                chainContent = new ChainContents()
                {
                    IdChain = editMessageViewModel.IdChain,
                    Index   = await _context.ChainContents
                              .Where(x => x.IdChain == editMessageViewModel.IdChain)
                              .OrderByDescending(x => x.Index)
                              .Select(x => x.Index)
                              .FirstOrDefaultAsync() + 1
                };
                await _context.ChainContents.AddAsync(chainContent);
            }
            chainContent.SendAfterSeconds   = editMessageViewModel.Hours * 60 * 60 + editMessageViewModel.Minutes * 60;
            chainContent.IsOnlyDayTime      = editMessageViewModel.IsOnlyDayTime;
            chainContent.IdExcludeFromChain = editMessageViewModel.IdExcludeFromChain;
            chainContent.IdGoToChain        = editMessageViewModel.IdGoToChain;

            chainContent.IdMessage = message.Id;
            await _context.SaveChangesAsync();

            return(RedirectToAction(nameof(EditById), new
            {
                idChain = editMessageViewModel.IdChain
            }));
        }