Generate Service (AI)

{
  "AppSettings": {
    "GenerateService": {
      "Provider": "OpenAI",
      "ApiKey": "sk-...",
      "Model": "gpt-4",
      "MaxTokens": 2000
    }
  }
}

import { apiService } from 'authscape';

const faqs = await apiService().post('/api/Generate/FAQ', {
  topic: 'AuthScape authentication',
  context: 'AuthScape is a multi-tenant SaaS platform with OAuth2 authentication',
  count: 5
});
// [
//   {
//     question: 'What authentication methods does AuthScape support?',
//     answer: 'AuthScape supports OAuth2 and OpenID Connect, including...'
//   },
//   ...
// ]

const blogPost = await apiService().post('/api/Generate/BlogPost', {
  title: 'Getting Started with Multi-Tenant SaaS',
  keywords: ['multi-tenant', 'SaaS', 'authentication'],
  tone: 'professional',
  length: 'medium',  // short, medium, long
  outline: [
    'Introduction to multi-tenancy',
    'Benefits of multi-tenant architecture',
    'Implementation challenges',
    'Best practices'
  ]
});
// {
//   title: 'Getting Started with Multi-Tenant SaaS',
//   content: '<p>Multi-tenant SaaS applications...</p>',
//   excerpt: 'Learn how to build scalable multi-tenant applications...',
//   suggestedTags: ['saas', 'architecture', 'multi-tenant']
// }

const meta = await apiService().post('/api/Generate/MetaDescription', {
  pageTitle: 'Pricing Plans - AuthScape',
  pageContent: 'Choose from our starter, pro, and enterprise plans...',
  targetKeywords: ['SaaS pricing', 'authentication platform']
});
// {
//   description: 'Compare AuthScape pricing plans. Start free, scale to enterprise...',
//   characterCount: 145
// }

const rewritten = await apiService().post('/api/Generate/Rewrite', {
  content: 'Our product is good for businesses.',
  style: 'professional',
  instruction: 'Make it more compelling and specific'
});
// {
//   content: 'Our enterprise platform empowers businesses to streamline operations...'
// }

const email = await apiService().post('/api/Generate/Email', {
  type: 'cold_outreach',
  recipientInfo: {
    name: 'John',
    company: 'Acme Corp',
    role: 'CTO'
  },
  product: 'AuthScape authentication platform',
  valueProposition: 'Reduce development time by 80%',
  callToAction: 'Schedule a demo'
});
// {
//   subject: 'Streamline Acme Corp\'s authentication - 15 min chat?',
//   body: 'Hi John,\n\nI noticed Acme Corp is...'
// }

const fixed = await apiService().post('/api/Generate/GrammarFix', {
  text: 'Their going to the store yesterday and buyed some items.'
});
// {
//   corrected: 'They went to the store yesterday and bought some items.',
//   corrections: [
//     { original: 'Their', corrected: 'They', type: 'grammar' },
//     { original: 'going', corrected: 'went', type: 'tense' },
//     { original: 'buyed', corrected: 'bought', type: 'spelling' }
//   ]
// }

[Route("api/[controller]/[action]")]
[ApiController]
[Authorize]
public class GenerateController : ControllerBase
{
    private readonly IGenerateService _generateService;

    [HttpPost]
    public async Task<IActionResult> FAQ([FromBody] FaqRequest request)
    {
        var faqs = await _generateService.GenerateFaqAsync(
            request.Topic,
            request.Context,
            request.Count
        );
        return Ok(faqs);
    }

    [HttpPost]
    public async Task<IActionResult> BlogPost([FromBody] BlogPostRequest request)
    {
        var post = await _generateService.GenerateBlogPostAsync(request);
        return Ok(post);
    }

    [HttpPost]
    public async Task<IActionResult> MetaDescription([FromBody] MetaRequest request)
    {
        var meta = await _generateService.GenerateMetaDescriptionAsync(
            request.PageTitle,
            request.PageContent,
            request.TargetKeywords
        );
        return Ok(meta);
    }
}

public class GenerateService : IGenerateService
{
    private readonly OpenAIClient _openAI;
    private readonly GenerateSettings _settings;

    public async Task<List<FaqItem>> GenerateFaqAsync(
        string topic,
        string context,
        int count)
    {
        var prompt = $@"
Generate {count} frequently asked questions about {topic}.

Context: {context}

Return as JSON array with 'question' and 'answer' fields.
";

        var response = await _openAI.GetChatCompletionsAsync(
            _settings.Model,
            new ChatCompletionsOptions
            {
                Messages = { new ChatMessage(ChatRole.User, prompt) },
                MaxTokens = _settings.MaxTokens
            }
        );

        var json = response.Value.Choices[0].Message.Content;
        return JsonSerializer.Deserialize<List<FaqItem>>(json);
    }
}

import { useState } from 'react';
import { apiService } from 'authscape';
import { TextField, Button, Select, MenuItem, Box, Typography, CircularProgress } from '@mui/material';

export default function ContentGenerator() {
  const [tool, setTool] = useState('faq');
  const [input, setInput] = useState('');
  const [output, setOutput] = useState(null);
  const [loading, setLoading] = useState(false);

  async function generate() {
    setLoading(true);
    try {
      let result;
      switch (tool) {
        case 'faq':
          result = await apiService().post('/api/Generate/FAQ', {
            topic: input,
            count: 5
          });
          break;
        case 'meta':
          result = await apiService().post('/api/Generate/MetaDescription', {
            pageTitle: input
          });
          break;
        case 'rewrite':
          result = await apiService().post('/api/Generate/Rewrite', {
            content: input,
            style: 'professional'
          });
          break;
      }
      setOutput(result);
    } catch (error) {
      alert('Generation failed');
    }
    setLoading(false);
  }

  return (
    <Box sx={{ maxWidth: 600, mx: 'auto', p: 3 }}>
      <Typography variant="h5" gutterBottom>AI Content Generator</Typography>

      <Select
        fullWidth
        value={tool}
        onChange={(e) => setTool(e.target.value)}
        sx={{ mb: 2 }}
      >
        <MenuItem value="faq">FAQ Generator</MenuItem>
        <MenuItem value="meta">Meta Description</MenuItem>
        <MenuItem value="rewrite">Content Rewriter</MenuItem>
        <MenuItem value="blog">Blog Post</MenuItem>
        <MenuItem value="email">Email Writer</MenuItem>
      </Select>

      <TextField
        fullWidth
        multiline
        rows={4}
        label="Input"
        value={input}
        onChange={(e) => setInput(e.target.value)}
        sx={{ mb: 2 }}
      />

      <Button
        variant="contained"
        onClick={generate}
        disabled={loading || !input}
      >
        {loading ? <CircularProgress size={24} /> : 'Generate'}
      </Button>

      {output && (
        <Box sx={{ mt: 3, p: 2, bgcolor: 'grey.100', borderRadius: 1 }}>
          <Typography variant="h6">Output</Typography>
          <pre>{JSON.stringify(output, null, 2)}</pre>
        </Box>
      )}
    </Box>
  );
}

services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("generate", config =>
    {
        config.PermitLimit = 10;
        config.Window = TimeSpan.FromMinutes(1);
    });
});

[RateLimiter("generate")]
public async Task<IActionResult> FAQ([FromBody] FaqRequest request)
{
    // ...
}