Beispiel #1
0
        protected AnswerItem SaveAnswerItem(string[] wordStrings, long userId)
        {
            var answer = new AnswerItem
            {
                Message = GetCommandIconUnicode()
            };

            if (!ValidateArray(wordStrings))
            {
                return(answer);
            }

            var maxStringLength = wordStrings.Select(a => a.Length).Max();

            if (maxStringLength > MaxImportRowLength)
            {
                answer.Message += $"String length must be less than {MaxImportRowLength}";
                return(answer);
            }

            var result = _parseProvider.ImportWords(wordStrings);

            if (result == null)
            {
                return(answer);
            }

            var uploadedResult = UploadWords(result, userId);

            if (uploadedResult.SuccessfulWords.Any())
            {
                answer.Message +=
                    $"These words have been added ({uploadedResult.SuccessfulWords.Length}): {Environment.NewLine} {string.Join(Environment.NewLine, uploadedResult.SuccessfulWords.Select(a => a.OriginalWord))}{Environment.NewLine}";
            }

            if (uploadedResult.FailedWords.Any())
            {
                answer.Message +=
                    $"These words have some parse troubles ({uploadedResult.FailedWords.Length}): {Environment.NewLine} {string.Join(Environment.NewLine, uploadedResult.FailedWords)}";
            }

            return(answer);
        }
Beispiel #2
0
        public override AnswerItem Reply(MessageItem mItem)
        {
            if (mItem.UserId != _adminUser)
            {
                return(new AnswerItem {
                    Message = "Access denied."
                });
            }

            if (string.IsNullOrEmpty(mItem.TextOnly))
            {
                return new AnswerItem {
                           Message = "Give me a file name to update."
                }
            }
            ;

            var fileName = mItem.Text;
            var filePath = Path.Combine(_preInstalledFolderPath, fileName);

            if (!fileName.EndsWith(Extension))
            {
                return new AnswerItem {
                           Message = "It is not a csv file."
                }
            }
            ;
            if (!File.Exists(filePath))
            {
                return new AnswerItem {
                           Message = "No such file."
                }
            }
            ;

            var serviceFolders = _repository.GetUserFolders(_serverUserId);

            ThreadPool.QueueUserWorkItem(cb =>
            {
                var resultString = new StringBuilder();

                fileName          = Path.GetFileNameWithoutExtension(filePath);
                var serviceFolder = serviceFolders.FirstOrDefault(a => a.Name == fileName);
                if (serviceFolder != null)
                {
                    _repository.DeleteFolder(serviceFolder.Id);
                    resultString.AppendLine("Old folder was removed.");
                }

                var fileBody = File.ReadAllBytes(filePath);

                var lines  = BytesToLines(fileBody);
                var result = _parseProvider.ImportWords(lines);

                //OwnerId will be taken from cookies, so we may not to specify it here
                var idFolder = _repository.AddFolder(new Folder {
                    Name = fileName, OwnerId = _serverUserId
                });
                _repository.SetCurrentFolder(_serverUserId, idFolder);
                var uploadWords = UploadWords(result, _serverUserId);

                resultString.AppendLine(uploadWords.SuccessfulWords.Any()
                    ? $"Words from folder {fileName} have been added."
                    : $"Can't add words to {fileName} folder.");

                _tClient.SendTextMessageAsync(mItem.ChatId, resultString.ToString(), ParseMode.Default, true, false, 0,
                                              new ReplyKeyboardRemove());
            });

            return(new AnswerItem {
                Message = "Import is running..."
            });
        }
    }
}
Beispiel #3
0
        public override AnswerItem Reply(MessageItem mItem)
        {
            var message = new AnswerItem
            {
                Message = GetCommandIconUnicode()
            };

            try
            {
                var idUser = mItem.ChatId;

                if (string.IsNullOrEmpty(mItem.TextOnly))
                {
                    message.Message = "Type a word to edit. Use chinese characters only!";
                }
                else if (mItem.TextOnly.StartsWith(EditCmd))
                {
                    if (!long.TryParse(
                            mItem.TextOnly.Split(new[] { EditCmdSeparator }, StringSplitOptions.RemoveEmptyEntries)
                            .LastOrDefault(),
                            out long idWord))
                    {
                        message.Message += "I can not edit your word now, sorry.";
                        return(message);
                    }

                    var lastWord = _repository.GetWord(idWord);
                    //_repository.GetCurrentUserWordStatistic(idUser);

                    if (lastWord == null)
                    {
                        message.Message += "No words to edit";
                        return(message);
                    }
                    message.Message = lastWord.ToEditString();
                }
                else if (mItem.TextOnly.Length > ImportCommand.MaxImportRowLength)
                {
                    message.Message =
                        $"Too much characters. Maximum is {ImportCommand.MaxImportRowLength}";
                }
                else
                {
                    var editedText = new[] { mItem.TextOnly };

                    if (!_importCommand.ValidateArray(editedText))
                    {
                        var wordToFind = _repository.GetWord(mItem.TextOnly, idUser);

                        if (wordToFind == null)
                        {
                            message.Message += "Bad text";
                            return(message);
                        }

                        message.Message = wordToFind.ToEditString();
                        return(message);
                    }

                    var word       = _parseProvider.ImportWords(editedText);
                    var parsedWord = word.SuccessfulWords.FirstOrDefault();

                    if (parsedWord == null)
                    {
                        message.Message += word.FailedWords.FirstOrDefault();
                        return(message);
                    }

                    _importCommand.UploadFiles(parsedWord);

                    _repository.EditWord(parsedWord);
                    message.Message += "The word has been updated";
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex);
                message.Message += ex.Message;
            }
            return(message);
        }