// public async Task<IActionResult> CreateTenantAsyncAndInviteAdmin([FromBody] CreateTenantCmd createTenantCmd)
public async Task <IActionResult> CreateQuestionAsync(int questionId, [FromBody] CreateQuestionCmd createQuestionCmd)
{
//data
CreateQuestionWriteContext ctx = new CreateQuestionWriteContext(
new EFList <Tenant>(_dbContext.Tenant),
new EFList <TenantUser>(_dbContext.TenantUser),
new EFList <User>(_dbContext.User),
new EFList <Post>(_dbContext.Post)
);
var dependencies = new QuestionDependencies();
dependencies.GenerateCodeVerificationToken = () => Guid.NewGuid().ToString();
dependencies.SendVerifyEmail = SendEmail;
var expr = from createQuestionResult in CreateQuestionDomain.CreateQuestion(createQuestionCmd)
// let user = createQuestionResult.SafeCast<CreateQuestionResult.QuestionCreated>().Select(p => p.Author)
let verifyCreateQuestionCmd = new VerifyCreateQuestionCmd()
from questionCreateVerified in QuestionCreateVerified(createQuestionCmd)
select new { createQuestionResult, VerifyCreateQuestionResult };
//var expr1 = from questionResult in CreateQuestionDomain.VerifyCreateQuestion(VerifyCreateQuestionCmd)
/// select questionResult;
CreateQuestionResult.ICreateQuestionResult result = await _interpreter.Interpret(expr, Unit.Default, new object());
return(result.Match(created => Ok(created),
notCreated => BadRequest(notCreated),
InvalidRequest => ValidationProblem()
));
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd cmd)
{
var dep = new QuestionsDependencies();
var questions = await _dbContext.Questions.ToListAsync();
_dbContext.Questions.AttachRange(questions);
var ctx = new QuestionsWriteContextC(new EFList <Question>(_dbContext.Questions));
var expr = from createQuestionResult in QuestionContext.CreateQuestion(cmd)
from checkLanguageResult in QuestionContext.CheckLanguage(new CheckLanguageCmd(cmd.Text))
from sendAckOwner in QuestionContext.SendAcknowledgementToQuestionOwner(new SendAcknowledgementToQuestionOwnerCmd(1, 2))
select createQuestionResult;
var r = await _interpreter.Interpret(expr, ctx, dep);
_dbContext.Questions.Add(new DatabaseModel.Models.Question {
QuestionId = Guid.NewGuid(), Titlu = cmd.Titlu, Text = cmd.Text, Tags = cmd.Tags
});
await _dbContext.SaveChangesAsync();
return(r.Match(
succ => (IActionResult)Ok(succ.Text),
notCreated => BadRequest("NotPosted"),
invalidRequest => ValidationProblem()
));
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd cmd)
{
var dep = new QuestionDependencies();
var questions = await _dbContext.QuestionModel.ToListAsync();
var ctx = new QuestionWriteContext(questions);
var expr = from CreateTenantResult in QuestionDomain.CreateQuestion(cmd)
select CreateTenantResult;
var r = await _interpreter.Interpret(expr, ctx, dep);
_dbContext.QuestionModel.Add(new DatabaseModel.Models.QuestionModel {
Title = cmd.Title, Description = cmd.Description, Tags = cmd.Tags
});
//var reply = await _dbContext.QuestionModel.Where(r => r.Title == "Intrebarea1").SingleOrDefaultAsync();
//_dbContext.QuestionModel.Update(reply);
await _dbContext.SaveChangesAsync();
return(r.Match(
succ => (IActionResult)Ok(succ),
fail => BadRequest("Reply could not be added")
));
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd cmd)
{
var dep = new QuestionDependencies();
var questions = await _dbContext.Questions.ToListAsync();
_dbContext.Questions.AttachRange(questions);
var ctx = new QuestionWriteContext(new EFList <Questions>(_dbContext.Questions));
// var ctx = new QuestionWriteContext(questions);
var expr = from createQuestionResult in QuestionContext.CreateQuestion(cmd)
from checkLanguageResult in QuestionContext.CheckLanguage(new CheckLanguageCmd(cmd.Body))
select createQuestionResult;
/* var expr = from createQuestionResult in QuestionContext.CreateQuestion(cmd)
* from checkLanguageResult in QuestionContext.CheckLanguage(new CheckLanguageCmd(cmd.Body))
* from sendAckToQuestionOwner in QuestionContext.SendAckToQuestionOwner(new SendAckToQuestionOwnerCmd(1, 2))
* select createQuestionResult; */
var r = await _interpreter.Interpret(expr, ctx, dep);
_dbContext.Questions.Add(new DatabaseModel.Models.Questions {
QuestionId = Guid.NewGuid(), Title = cmd.Title, Body = cmd.Body, Tags = cmd.Tags
});
//var question=await _dbContext.Questions.Where(r => r.QuestionId== new Guid("20000000-0000-0000-0000-000000000000")).SingleOrDefaultAsync();
// _dbContext.Questions.Update(question);
await _dbContext.SaveChangesAsync();
return(r.Match(
created => (IActionResult)Ok(created.Body),
notcreated => BadRequest("NotPosted"),
invalidRequest => ValidationProblem()
));
}
public async Task <IActionResult> CreateQuestionAsync([FromBody] CreateQuestionCmd createQuestionCmd)
{
var ctx = new QuestionsWriteContext(new EFList <Post>(_dbContext.Post), new EFList <User>(_dbContext.User));
var dependencies = new QuestionsDependency();
dependencies.GenerateConfirmationToken = () => Guid.NewGuid().ToString();
dependencies.SendConfirmationEmail = SendEmailToOwner;
var expr = from createResult in QuestionsDomain.CreateQuestion(createQuestionCmd)
let title = createResult.SafeCast <CreateQuestionResult.QuestPublished>().Select(p => p.Title)
let body = createResult.SafeCast <CreateQuestionResult.QuestPublished>().Select(p => p.Body)
let tag = createResult.SafeCast <CreateQuestionResult.QuestPublished>().Select(p => p.Tag)
let tenantId = createResult.SafeCast <CreateQuestionResult.QuestPublished>().Select(p => p.TenantId)
let userId = createResult.SafeCast <CreateQuestionResult.QuestPublished>().Select(p => p.UserId)
let user = createResult.SafeCast <CreateQuestionResult.QuestPublished>().Select(p => p.User)
let confirmQuest = new CreateQuestionCmd((string)title, (string)body, (string)tag, (int)tenantId, (Guid)userId, (TenantUser)user)
from CreateQuestionResult in QuestionsDomain.CreateQuestion(confirmQuest)
select new { createResult, CreateQuestionResult };
var r = await _interpreter.Interpret(expr, ctx, dependencies);
_dbContext.SaveChanges();
return(r.createResult.Match(
created => (IActionResult)Ok(created.Title),
notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Question could not be created."),
invalidRequest => BadRequest("Invalid request.")));
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd cmd)
{
var dep = new QuestionDependencies();
var questions = await _dbContext.QuestionModel.ToListAsync();
// var ctx = new QuestionWriteContext(questions);
_dbContext.QuestionModel.AttachRange(questions);
var ctx = new QuestionWriteContext(new EFList <QuestionModel>(_dbContext.QuestionModel));
var expr = from CreateQuestionResult in QuestionContext.CreateQuestion(cmd)
//let checkLanguageCmd = new CheckLanguageCmd()
//select CreateQuestionResult;
from checkLanguageResult in QuestionContext.CheckLanguage(new CheckLanguageCmd(cmd.Description))
from sendAckToQuestionOwnerCmd in QuestionContext.SendQuestionOwnerAcknowledgment(new SendQuestionOwnerAcknowledgementCmd(1, 2))
select CreateQuestionResult;
var r = await _interpreter.Interpret(expr, ctx, dep);
_dbContext.QuestionModel.Add(new DatabaseModel.Models.QuestionModel {
QuestionId = Guid.NewGuid(), Title = cmd.Title, Description = cmd.Description, Tags = cmd.Tags
});
//var reply = await _dbContext.QuestionModel.Where(r => r.Title == "Intrebarea1").SingleOrDefaultAsync();
//_dbContext.QuestionModel.Update(reply);
await _dbContext.SaveChangesAsync();
return(r.Match(
succ => (IActionResult)Ok("Successfully"),
fail => BadRequest("Reply could not be added")
));
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd createQuestionCmd)
{
QuestionWriteContext ctx = new QuestionWriteContext(
new EFList <Question>(_dbContext.Question),
new EFList <User>(_dbContext.User));
var dependencies = new QuestionDependencies();
dependencies.GenerateInvitationToken = () => Guid.NewGuid().ToString();
dependencies.SendInvitationEmail = (InvitationLetter letter) => async() => new InvitationAcknowledgement(Guid.NewGuid().ToString());
var expr = from createQuestionResult in QuestionDomain.CreateQuestion(createQuestionCmd)
let question = createQuestionResult.SafeCast <CreateQuestionResult.QuestionCreated>().Select(p => p.question)
let createQuestionCmd = new CreateQuestionCmd(question)
from CreateQuestionResult in QuestionDomain.CreateQuestion(createQuestionCmd)
select new { createQuestionResult, CrateQuestionResult };
var r = await _interpreter.Interpret(expr, ctx, dependencies);
_dbContext.SaveChanges();
return(r.createQuestiontResult.Match(
created => (IActionResult)Ok(created.question.TenantId),
notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Tenant could not be created."),//todo return 500 (),
invalidRequest => BadRequest("Invalid request.")));
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd cmd)
{
QuestionsWriteContext ctx = new QuestionsWriteContext(
new EFList <Post>(_dbContext.Post));
var dep = new QuestionsDependencies();
var questions = await _dbContext.Post.ToListAsync();
//var questions = await _dbContext.Post.Where(q => q.PostTypeId == 1).ToListAsync();
_dbContext.Post.AttachRange(questions);
var expr = from createQuestionResult in QuestionsDomain.CreateQuestion(cmd)
//let checkLanguageCmd = new CheckLanguageCmd()
//select CreateQuestionResult;
from checkLanguageResult in QuestionsDomain.CheckLanguage(new CheckLanguageCmd(cmd.PostText))
//from sendAckToQuestionOwnerCmd in QuestionsDomain.SendQuestionOwnerAcknowledgement(new SendQuestionOwnerAcknowledgementCmd())
select new { createQuestionResult, checkLanguageResult };
var r = await _interpreter.Interpret(expr, ctx, dep);
//var reply = await _dbContext.QuestionModel.Where(r => r.Title == "intrebTest").SingleOrDefaultAsync();
//_dbContext.Question.Update(reply);
//await _dbContext.SaveChangesAsync();
_dbContext.SaveChanges();
return(r.createQuestionResult.Match(
created => (IActionResult)Ok("PostID of question created:" + created.question.PostId),
notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Question could not be created."),//todo return 500 (),
invalidRequest => BadRequest("Invalid request.")));
}
public async Task <string> CreateQuestion1([FromBody] CreateQuestionCmd question)
{
QuestionContext ctx = new QuestionContext(
new EFList <Question>(_dbContext.Question));
var dep = new QuestionDepend();
var exp = from createQuestionResult in QuestionDomain.CreateQuestion(question)
select new { createQuestionResult };
var r = await _interpreter.Interpret(exp, ctx, dep);
Console.WriteLine("fddddddddddddd");
_dbContext.SaveChanges();
if (_client.IsInitialized == false)
{
await _client.Connect();
}
var friend = _client.GetGrain <IEmailSender>(0);
var a = _dbContext.Utilizatori.Where(c => c.IdUser == question.IdUser);
foreach (Utilizatori u in a)
{
var response = await friend.SendEmailAsync(u.Email);
}
return("adaugat");
}
public async Task <IActionResult> CreateAndConfirmationQuestion([FromBody] CreateQuestionCmd createQuestionCmd)
{
QuestionWriteContext ctx = new QuestionWriteContext(
new EFList <Post>(_dbContext.Post),
new EFList <User>(_dbContext.User));
var dependencies = new QuestionDependencies();
dependencies.GenerateConfirmationToken = () => Guid.NewGuid().ToString();
dependencies.SendConfirmationEmail = SendConfirmationEmail;
var expr = from createQuestionResult in QuestionDomain.CreateQuestion(createQuestionCmd)
let user = createQuestionResult.SafeCast <CreateQuestionResult.QuestionCreated>().Select(p => p.Author)
let confirmationQuestionCmd = new ConfirmationQuestionCmd(user)
from ConfirmationQuestionResult in QuestionDomain.ConfirmQuestion(confirmationQuestionCmd)
select new { createQuestionResult, ConfirmationQuestionResult };
var r = await _interpreter.Interpret(expr, ctx, dependencies);
// _dbContext.Post.Add(new Post { PostTypeId=1,Title=createQuestionCmd.Title, PostText=createQuestionCmd.Body});
await _dbContext.SaveChangesAsync();
return(r.createQuestionResult.Match(
created => (IActionResult)Ok(created.Question.PostId),
notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Question could not be created."),//todo return 500 (),
invalidRequest => BadRequest("Invalid request.")));
}
static void Main(string[] args)
{
var cmdQuestion = new CreateQuestionCmd("Titlu", "Descriere intrebare", "C/C++");
var resultQuestion = CreateQuestion(cmdQuestion);
resultQuestion.Match(
ProcessQuestionCreated,
ProcessQuestionNotCreated,
ProcessInvalidQuestion
);
Console.ReadLine();
}
public async Task <IActionResult> CreateQuestion(CreateQuestionCmd cmd)
{
var dep = new QuestionDependencies();
var ctx = new QuestionWriteContext();
var expr = from createTenantResult in QuestionContext.CreateQuestion(cmd)
select createTenantResult;
var r = await _interpreter.Interpret(expr, ctx, dep);
return(r.Match(
created => Ok(created),
notCreated => BadRequest(notCreated),
invalidRequest => ValidationProblem()
));
}
public async Task <string> CreateQuestion1([FromBody] CreateQuestionCmd question)
{
QuestionContext ctx = new QuestionContext(
new EFList <Question>(_dbContext.Question));
var dep = new QuestionDepend();
var exp = from createQuestionResult in QuestionDomain.CreateQuestion(question)
select new { createQuestionResult };
var r = await _interpreter.Interpret(exp, ctx, dep);
_dbContext.SaveChanges();
return("adaugat");
}
public async Task <IActionResult> CreateQuestionAsyncAndSendEmail([FromBody] CreateQuestionCmd createQuestionCmd)
{
QuestionWriteContext ctx = new QuestionWriteContext(
new EFList <Post>(_dbContext.Post),
new EFList <User>(_dbContext.User));
var expr = from createQuestionResult in QuestionDomain.CreateQuestion(createQuestionCmd)
select createQuestionResult;
var r = await _interpreter.Interpret(expr, ctx, dependencies);
_dbContext.SaveChanges();
return(r.Match(
created => Ok(created.Question.PostId),
notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Question could not be created."),//todo return 500 (),
invalidRequest => BadRequest("Invalid request.")));
}
public async Task <IActionResult> CreateQuestionAsyncAndConfirmation([FromBody] CreateQuestionCmd createQuestionCmd)
{
QuestionWriteContext ctx = new QuestionWriteContext(new List <QuestionSummary>());
var dependecies = new QuestionDependencies();
dependecies.SendConfirmationEmail = (ConfirmationLetter letter) => async() => new ConfirmationAcknowledgement(Guid.NewGuid().ToString());
var expr = from createQuestionResult in QuestionDomain.CreateQuestion(createQuestionCmd)
let questionSummary = createQuestionResult.SafeCast <CreateQuestionResult.QuestionCreated>().Select(p => p.QuestionSummary)
let confirmationCmd = new ConfirmationQuestionCmd(questionUser)
from confirmationResult in QuestionDomain.ConfirmQuestion(confirmationCmd)
select new { createQuestionResult, confirmationResult };
var r = await _interpreter.Interpret(expr, ctx, dependecies);
return(r.createQuestionResult.Match(
created => (IActionResult)Ok(created.QuestionSummary.QuestionId),
notCreated => BadRequest("Question could not be created."),
invalidRequest => BadRequest("Invalid request.")));
}
public static ICreateQuestionResult CreateQuestion(CreateQuestionCmd createQuestionCommand)
{
if (string.IsNullOrWhiteSpace(createQuestionCommand.Title) || string.IsNullOrWhiteSpace(createQuestionCommand.Description))
{
var errors = new List <string>()
{
"Invalid title or description"
};
return(new QuestionValidationFailed(errors));
}
if (new Random().Next(10) > 1)
{
return(new QuestionNotCreated("Question could not be verified"));
}
var questionId = Guid.NewGuid();
var results = new QuestionCreated(questionId, createQuestionCommand.Title, createQuestionCommand.Description, createQuestionCommand.Tag);
return(results);
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd cmd)
{
QuestionWriteContext ctx = new QuestionWriteContext(new EFList <Post>(_dbContext.Post));
var dependencies = new QuestionDependencies();
dependencies.QuestionEmail = SendEmail;
var exp = from CreateQuestionResult in QuestionContext.CreateQuestion(cmd)
select CreateQuestionResult;
var r = await _interpreter.Interpret(exp, ctx, dependencies);
_dbContext.SaveChanges();
return(r.Match(
created => (IActionResult)Ok("Question posted"),
notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Question could not be posted.")
));
}
public async Task <ActionResult> CreateQuestion([FromBody] CreateQuestionCmd cmd)
{
QuestionWriteContext ctx = new QuestionWriteContext(new EFList <Post>(_dbContext.Post));
var dependencies = new QuestionDependencies();
dependencies.SendConfirmationEmail = (ConfirmationLetter response) => async() => new ConfirmationAcknowledgement(Guid.NewGuid().ToString());
var expr = from questionResult in QuestionDomain.CreateQuestion(cmd)
select questionResult;
var result = await _interpreter.Interpret(expr, ctx, dependencies);
_dbContext.SaveChanges();
return(result.Match(
created => Ok(created),
notCreated => (ActionResult)BadRequest("Question not created"),
invalidRequest => BadRequest("Invalid request")));
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd cmd)
{
var questionDependencies = new QuestionDependencies();
//var questionWriteContext= await _db_Context.Question.ToList();
var questionWriteContext = new QuestionWriteContext(new EFList <Question>(_db_Context.Question));
var expr = from createQuestionResult in QuestionsDomain.CreateQuestion(cmd)
/* from checkLanguageResult in QuestionsDomain.CheckLanguage(new CheckLanguageCmd(cmd.Body))
* from sendAckToQuestionOwnerCmd in QuestionsDomain.SendAckToQuestionOwner(new ReceivedAckSentToQuestionOwnerCmd(1, 2))*/
select createQuestionResult;
var result = await _interpreter.Interpret(expr, questionWriteContext, new object());
// var result = await _interpreter.Interpret(expr, questionWriteContext, questionDependencies);
//_db_Context.Question.Add(new DatabaseModel.Models.Question { QuestionId = 1, Title = cmd.Title, Body = cmd.Body, Tags = cmd.Tags });
// var question = await _dbContext.Question.Where(r => r.QuestionId == 1).SingleOrDefaultAsync();
// _dbContext.Question.Update(question);
await _dbContext.SaveChangesAsync();
return(result.Match(
create => (CreateTenantResult.TenantCreated)(IActionResult) Ok(create.QuestionId),
notcreated => BadRequest("NotPosted"),
invalidRequest => ValidationProblem()
));
/* return result.createQuestionResult.Match(
* created => (IActionResult)Ok(qe
* QuestionPosted),
* notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Question could not be created."),//todo return 500 (),
* invalidRequest => BadRequest("Invalid request."));
* /*return result.Match(created => (IActionResult)Ok(created),
* notCreated => BadRequest(notCreated),
* invalidRequest => ValidationProblem()
* );*/
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd cmd)
{
var dep = new QuestionDependencies();
var questions = await _dbContext.Questions.ToListAsync();
var ctx = new QuestionWriteContext(new EFList <Questions>(_dbContext.Questions));
var expr = from createQuestionResult in QuestionContext.CreateQuestion(cmd) select createQuestionResult;
var r = await _interpreter.Interpret(expr, ctx, dep);
_dbContext.Questions.Add(new DatabaseModel.Models.Questions {
QuestionId = Guid.NewGuid(), Title = cmd.Title, Body = cmd.Body, Tags = cmd.Tags
});
await _dbContext.SaveChangesAsync();
return(r.Match(
created => (IActionResult)Ok(created.Body),
notcreated => BadRequest("NotPosted"),
invalidRequest => ValidationProblem()
));
}
public async Task <IActionResult> CreateQuestionAsyncAndSendEmail([FromBody] CreateQuestionCmd createQuestionCmd)
{
QuestionWriteContext ctx = new QuestionWriteContext(
new EFList <Post>(_dbContext.Post));
var dependencies = new QuestionDependencies();
dependencies.SendConfirmationEmail = (ConfirmationLetter letter) => async() => new ConfirmationAcknowledgement(Guid.NewGuid().ToString());
dependencies.SendConfirmationEmail = SendEmail;
var expr = from createQuestionResult in QuestionDomain.CreateQuestion(createQuestionCmd)
select createQuestionResult;
var r = await _interpreter.Interpret(expr, ctx, dependencies);
_dbContext.SaveChanges();
return(r.Match(
created => Ok(created.Question.PostId),
notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Question could not be created."),//todo return 500 (),
invalidRequest => BadRequest("Invalid request.")));
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd cmd)
{
var dep = new QuestionsDependencies();
var replies = await _dbContext.Questions.ToListAsync();
_dbContext.Questions.AttachRange(replies);
var ctx = new QuestionsWriteContextC(new EFList <Question>(_dbContext.Questions));
var expr = from createTenantResult in QuestionContext.CreateQuestion(cmd)
from checkLanguageResult in QuestionContext.CheckLanguage(new CheckLanguageCmd(cmd.Text))
select createTenantResult;
var r = await _interpreter.Interpret(expr, ctx, dep);
return(r.Match(
created => Ok(created),
notCreated => BadRequest(notCreated),
invalidRequest => ValidationProblem()
));
}
public async Task <IActionResult> CreateQuestion([FromBody] CreateQuestionCmd createQuestionCmd)
{
QuestionWriteContext ctx = new QuestionWriteContext(
new EFList <Post>(_dbContext.Post));
var dependencies = new QuestionDependencies();
var expr = from createQuestionResult in QuestionDomain.CreateQuestion(createQuestionCmd)
// let adminUser = createQuestionResult.SafeCast<CreateQuestionResult.TenantCreated>().Select(p => p.AdminUser)
// let inviteAdminCmd = new InviteTenantAdminCmd(adminUser)
from checkLanguageResult in QuestionDomain.CheckLanguage(new CheckLanguageCmd(createQuestionCmd.Body))
select new { createQuestionResult, checkLanguageResult };
var r = await _interpreter.Interpret(expr, ctx, dependencies);
_dbContext.SaveChanges();
return(r.createQuestionResult.Match(
created => (IActionResult)Ok("OK"),
notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Tenant could not be created."),//todo return 500 (),
invalidRequest => BadRequest("Invalid request.")));
}
public static Port <ICreateQuestionResult> CreateQuestion(CreateQuestionCmd createQuestionCmd) => NewPort <CreateQuestionCmd, ICreateQuestionResult>(createQuestionCmd);
public static Port <ICreateQuestionResult> CreateQuestion(CreateQuestionCmd cmd) => NewPort <CreateQuestionCmd, ICreateQuestionResult>(new CreateQuestionCmd(cmd.Title, cmd.Body, cmd.Tag, cmd.TenantId, cmd.UserId, cmd.TenantUser)); //string title, string body, string tag, int tenantId, Guid userId, User user
