Esempio n. 1
0
        internal async Task <(ValidationError error, TemplateField field)> SetRandomTableField(TemplateField field)
        {
            ValidationError err = ValidationError.None;

            try
            {
                var match = validationRegexs[field.FieldType].Match(field.Value);

                if (!match.Success)
                {
                    field.Valid = false;
                    return(ValidationError.InvalidTag, field);
                }

                var table = match.Groups[1].Value.Trim();

                var json = new TemplateTbl
                {
                    TableName = table
                };

                // if table uses variables don't check the db
                if (table.Contains('{') || table.Contains('}'))
                {
                    var(valid, vars) = ParseVariableNames(table);

                    err            = valid ? ValidationError.None : ValidationError.InvalidTag;
                    field.Valid    = valid;
                    json.Variables = vars;
                }
                else
                {
                    var result = await randomTableService.TableExists(table);

                    if (!result.Result)
                    {
                        field.Valid = false;
                        err         = ValidationError.TableDoesNotExist;
                    }
                }

                field.TemplateJson = JsonConvert.SerializeObject(json);

                field.Valid = true;
            }
            catch (Exception ex)
            {
                Log.Error($"Exception parsing {field.Value}. ex:{ex.Message}");
                Log.Debug(ex.StackTrace);
                field.Valid = false;
                err         = ValidationError.InvalidTag;
            }

            return(err, field);
        }
        private async Task <string> TableResult(TemplateField field, Dictionary <string, string> generatedVars)
        {
            try
            {
                var tbl       = JsonConvert.DeserializeObject <TemplateTbl>(field.TemplateJson);
                var tableName = tbl.TableName;

                foreach (var variable in tbl.Variables)
                {
                    if (!generatedVars.ContainsKey(variable))
                    {
                        return("(Variable for table name missing!)");
                    }
                    tableName = tableName.Replace($"{{{variable}}}", generatedVars[variable]);
                }

                var exists = await tableService.TableExists(tableName);

                if (!exists.Result)
                {
                    return($"({tableName} table doesn't exist!)");
                }

                var tableVals = await tableService.GetRandomTableByName(tableName);

                var valsToSelectFrom = new List <string>();

                foreach (var entry in tableVals.Result.Entries)
                {
                    if (entry.UpperBound == entry.LowerBound)
                    {
                        valsToSelectFrom.Add(entry.Entry);
                    }
                    else
                    {
                        for (var i = entry.LowerBound; i < entry.UpperBound; i++)
                        {
                            valsToSelectFrom.Add(entry.Entry);
                        }
                    }
                }

                return(valsToSelectFrom[rng.Next(valsToSelectFrom.Count)]);
            }
            catch (Exception e)
            {
                Log.Error($"Exception calling TableResult(TemplateField field), ex:{e.Message}");
                Log.Debug(e.StackTrace);
                return("(Table error!)");
            }
        }