private async Task <bool> CheckPremiumAccess(HasAccessToScriptQuery request, ScriptDto script)
{
if (!request.UserId.HasValue)
{
return(false);
}
var date = DateTimeOffset.UtcNow;
var count = await _db.ScriptAccess
.Where(w => w.ScriptId == script.Id && w.UserId == request.UserId && w.Expiration.HasValue &&
w.Expiration.Value > date).Select(w => w.Instances.GetValueOrDefault(1)).SumAsync();
if (!script.Instances.HasValue)
{
return(count > 0);
}
var clients = await _mediator.Send(new GetRunningClientsQuery { UserId = request.UserId.Value });
var dic = clients.GroupBy(w => w.Tag)
.ToDictionary(w => w.Key, c => c.OrderByDescending(w => w.LastUpdate).ToList());
var realCount = dic.Count(w => w.Value.First().ScriptName == script.Name);
return(count > realCount);
}
private void RunScript(List <ScriptDto> listScript)
{
try
{
if (String.IsNullOrWhiteSpace(appArgs.ScriptId) || !listScript.Any(r => r.Id.Equals(appArgs.ScriptId)))
{
log.Error("Identifiant du script absent ou non reconnu ('{0}' : {1})", appArgs.ScriptId,
String.Join(", ", listScript.Select(r => r.Id)));
appExitCode = EnumExitCode.NoScriptOrNotKnown;
return;
}
ScriptDto scriptDto = listScript.FirstOrDefault(r => r.Id.Equals(appArgs.ScriptId));
log.Info("Script à lancer (id: {0}, script: {1})", scriptDto.Id, scriptDto.Path);
ScriptRunner sRun = new ScriptRunner(scriptDto);
_handler += new EventHandler(sRun.HandleUnusalExit);
SetConsoleCtrlHandler(_handler, true);
sRun.Run(appArgs.ScriptArgsInput);
}
catch (Exception e)
{
log.Error("Erreur inattendue : {0}", e.Message);
ExceptionHandlingUtils.LogAndHideException(e, isWarnMsgAndDebugStack: true);
appExitCode = EnumExitCode.ErrorScriptRunner;
return;
}
}
public async Task <ScriptHeaderDto> Create(ScriptDto script, int userId, CancellationToken cancellationToken)
{
try
{
var owner = await _database.Users.FirstOrDefaultAsync(x => x.Id == userId, cancellationToken);
Script dbScript = new Script
{
Name = script.Name,
Instruction = script.Instruction,
Owner = owner
};
var result = await _database.Scripts.AddAsync(dbScript, cancellationToken);
await _database.SaveChangesAsync(cancellationToken);
return(result.Adapt <ScriptHeaderDto>());
}
catch (Exception ex)
{
_logger.LogError(ex, "Error during script creation.");
throw;
}
}
public ActionResult SaveScript(ScriptDto newScript, HttpPostedFileBase file)
{
if (!ModelState.IsValid) /* Server side validation */
{
TempData["MessageType"] = WebMessageType.Failure;
TempData["Message"] = "Failed to save script due to invalid data";
return(RedirectToAction("Add"));
}
try
{
if (Request.Files.Count > 0)
{
var fileName = Path.GetFileName(file.FileName);
if (fileName != null)
{
Guid newFileName = Guid.NewGuid(); //to rename document
//file path location comes from the Web.config file
try
{
var path = Path.Combine(ConfigHelper.GetScriptPath(), newFileName + ".ps1");
file.SaveAs(Server.MapPath(path)); /*create new doc and upload it */
newScript = new ScriptDto()
{
Id = newScript.Id,
Name = newScript.Name,
Description = newScript.Description,
Version = newScript.Version,
MimeType = file.ContentType,
ScriptFile = newFileName,
UploadDate = DateTime.Now,
};
_scriptFileController.ModifyScript(UserId, newScript, newScript.Id <= 0 ? EntityModification.Create : EntityModification.Update);
}
catch (Exception e)
{
TempData["MessageType"] = WebMessageType.Failure;
TempData["Message"] = $"Failed to upload document, error: {e.Message}";
}
}
}
TempData["MessageType"] = WebMessageType.Success;
TempData["Message"] = $"New script {newScript.Name} saved successfully";
}
catch (Exception e)
{
TempData["MessageType"] = WebMessageType.Failure;
TempData["Message"] = $"Failed to save script {newScript.Name}, error: {e}";
return(RedirectToAction("Add"));
}
//return to index
return(RedirectToAction("Index"));
}
private string GenerateMain(InputDto inputDto, TemplateDto templateDto, ScriptDto scriptDto)
{
string mainScript = string.Format(
templateDto.MainTemplate,
inputDto.Verb,
scriptDto.WeekRange,
//scriptDto.EventsScript,
scriptDto.NewsScript,
inputDto.Youtube,
inputDto.YoutubeText);
return(mainScript);
}
public ScriptAccessDto(ScriptAccess access)
{
Id = access.Id;
UserId = access.UserId;
Script = new ScriptDto(access.Script);
OrderId = access.OrderId ?? 0;
Timestamp = access.Timestamp;
Expiration = access.Expiration;
Instances = access.Instances;
Recurring = access.Recurring;
var now = DateTimeOffset.UtcNow;
IsExpired = Expiration.HasValue && Expiration.Value < now;
}
/// <summary>
/// GET: Script/UpdateScript/id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult UpdateScript(int id)
{
var model = new ScriptDto();
if (id == 0)
{
// new script
return(View("Add", model));
}
// update script
model = (ScriptDto)_scriptFileController.GetScript(UserId, id);
return(View("Add", model));
}
public static string GetScriptArgsTpl(ScriptDto scriptDto)
{
StringBuilder str = new StringBuilder("-ExecutionPolicy RemoteSigned ");
PowershellParams p = scriptDto.PowershellParams;
str.AppendFormat("{0}", p.NoProfile ? "-NoProfile " : "");
str.AppendFormat("{0}", p.NoExit ? "-NoExit " : "");
str.AppendFormat("{0}", p.NoLogo ? "-NoLogo " : "");
str.AppendFormat("{0}", p.WindowStyle != null ? "-WindowStyle " + p.WindowStyle + " " : "");
str.AppendFormat("-File \"{0}\" {1}", scriptDto.Path, scriptDto.Args);
return(str.ToString());
}
internal List <ScriptDto> GetListScripts()
{
List <ScriptDto> retList = new List <ScriptDto>();
XmlNodeList list = XmlUtils.GetElementsXpath(xmlFile.Root, ".//script");
foreach (XmlElement xmlElement in list)
{
if (!xmlElement.HasAttribute("id"))
{
Console.WriteLine("Balise script detectée sans attribut id. Ignorée.");
continue;
}
ScriptDto s = new ScriptDto()
{
Id = xmlElement.Attributes["id"].Value,
Path = XmlUtils.GetElementXpath(xmlElement, "./path/text()")?.Value,
Wd = XmlUtils.GetElementXpath(xmlElement, "./wd/text()")?.Value,
Args = XmlUtils.GetElementXpath(xmlElement, "./args/text()")?.Value,
};
if (retList.Any(r => r.Id.Equals(s.Id)))
{
Console.WriteLine("Balise script detectée sans attribut id. Ignorée.");
continue;
}
XmlNode psParams = XmlUtils.GetElementXpath(xmlElement, "./powershellParams");
if (psParams != null)
{
XmlSerializer serializer = new XmlSerializer(typeof(PowershellParams));
PowershellParams p = null;
using (XmlNodeReader reader = new XmlNodeReader(psParams))
{
p = (PowershellParams)serializer.Deserialize(reader);
}
s.PowershellParams = p;
}
retList.Add(s);
}
return(retList);
}
private void RunScriptInteractive(List <ScriptDto> listScript)
{
while (true)
{
int nbEltParLigne = 3;
StringBuilder strShow = new StringBuilder();
String tpl = "[{0:" + new String(' ', 2) + "}] {1,-25}";
tpl = "[{0}] {1,-25}";
int i = 0;
for (; i < listScript.Count; i++)
{
ScriptDto scriptDto = listScript[i];
strShow.AppendFormat(tpl, i, scriptDto.Id);
if ((i + 1) % nbEltParLigne == 0)
{
strShow.AppendLine();
}
}
strShow.AppendFormat(tpl, i, "Quitter");
Console.WriteLine(strShow.ToString());
Console.WriteLine();
Console.Write("Faites votre choix : ");
String choiceStr = Console.ReadLine();
int choice = -1;
if ((choice = MiscAppUtils.IntParse(choiceStr)) >= 0)
{
if (choice == i)
{
break;
}
if (RunScriptInteractiveSub(listScript[choice]))
{
return;
}
Console.Clear();
}
}
}
public ScriptDto ScriptGeneration(InputDto inputDto)
{
var templateDto = templateRetriever.ReadingTemplates();
var scriptDto = new ScriptDto();
scriptDto.WeekRange = weekRangeCalculator.CalculateWeekRange();
//scriptDto.EventsScript = GenerateEvents(inputDto, templateDto);
scriptDto.NewsScript = GenerateNews(inputDto, templateDto);
scriptDto.MainScript = GenerateMain(inputDto, templateDto, scriptDto);
return(scriptDto);
}
public ScriptDto ScriptGeneration(InputDto inputDto)
{
var templateDto = templateRetriever.ReadingTemplates();
var scriptDto = new ScriptDto();
ReadingLongGeneration(inputDto, templateDto, scriptDto);
ReadingShortGeneration(inputDto, templateDto, scriptDto);
ListeningLongGeneration(inputDto, templateDto, scriptDto);
ListeningShortGeneration(inputDto, templateDto, scriptDto);
return(scriptDto);
}
public ActionResult ConfirmDeleteScript(int id)
{
ScriptDto model = new ScriptDto()
{
Id = id
};
try
{
model.Name = _scriptFileController.GetScript(UserId, id).Name; //complete model details
}
catch (Exception exception)
{
TempData["MessageType"] = WebMessageType.Failure;
TempData["Message"] = $"Failed to retrieve script, error: {exception.Message}";
}
return(View("ConfirmDeleteScript", model));
}
public async Task <ActionResult <string> > PostAsync([FromForm] ScriptDto dto)
{
var insertDto = await _scriptAppService.InsertAsync(dto);
return(Ok(insertDto.Id));
}
public Task <ScriptValidationDto> ValidateScript(ScriptDto script)
{
return(Post <ScriptValidationDto, ScriptDto>(
$"{BaseUri}/{RouteConstants.PREFIX}/{RouteConstants.POST_SCRIPT_VALIDATION}", script));
}
public async Task <IActionResult> CreateScript(ScriptDto script, CancellationToken cancellationToken)
{
var created = await _service.Create(script, HttpContext.GetCurrentUserId(), cancellationToken);
return(Created(string.Empty, created));
}
public async Task <IActionResult> UpdateScript(ScriptDto script, CancellationToken cancellationToken)
{
return(Ok(await _service.Update(script, HttpContext.GetCurrentUserId(), cancellationToken)));
}
public async Task <ScriptHeaderDto> Update(ScriptDto script, int userId, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
private bool RunScriptInteractiveSub(ScriptDto scriptDto)
{
Console.WriteLine();
bool isDoReturn = SubA();
return(isDoReturn);
bool SubA()
{
while (true)
{
String msgPresentScript = $"Script {scriptDto.Id} :";
Console.WriteLine(new String('=', msgPresentScript.Length + 2));
Console.WriteLine($" {msgPresentScript}");
Console.WriteLine(new String('=', msgPresentScript.Length + 2));
Console.WriteLine("[0] Lancer le script");
Console.WriteLine("[1] Revenir en arrière");
Console.WriteLine();
Console.Write("Faites votre choix : ");
String choiceStr = Console.ReadLine();
int choice = -1;
if ((choice = MiscAppUtils.IntParse(choiceStr)) >= 0)
{
if (choice == 1)
{
break;
}
else
{
if (SubB())
{
return(true);
}
Console.Clear();
}
}
}
return(false);
}
bool SubB()
{
while (true)
{
Console.WriteLine();
string argScript = ScriptRunner.GetScriptArgsTpl(scriptDto);
int nbArgsScript = ScriptRunner.ExtractNbArgs(argScript);
if (nbArgsScript == 0)
{
Console.WriteLine("Aucun argument à fournir pour ce script");
}
else
{
Console.WriteLine("Paramètres de lancement :");
Console.WriteLine(argScript);
Console.WriteLine();
List <String> listArgs = new List <string>(nbArgsScript);
for (int i = 0; i < nbArgsScript; i++)
{
Console.Write("Valorisez %1: ");
listArgs.Insert(i, Console.ReadLine());
}
listArgs.Insert(0, String.Join(" ", listArgs));
Console.WriteLine();
string argScriptRepl = ScriptRunner.ReplaceArgsInTpl(argScript, listArgs);
Console.WriteLine("Le script sera lancé avec ces paramètres :");
Console.WriteLine(argScriptRepl);
Console.WriteLine();
Console.WriteLine();
Console.Write("Voulez-vous continuer ? [o/n/a] : ");
String choiceStr = Console.ReadLine();
if (choiceStr == null || choiceStr.Equals("n", StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
else if (choiceStr.Equals("a", StringComparison.CurrentCultureIgnoreCase))
{
return(false);
}
appArgs.ScriptArgsInput = listArgs;
}
try
{
ScriptRunner sRun = new ScriptRunner(scriptDto);
_handler += new EventHandler(sRun.HandleUnusalExit);
SetConsoleCtrlHandler(_handler, true);
sRun.Run(appArgs.ScriptArgsInput);
}
catch (Exception e)
{
Thread.Sleep(5000);
return(false);
}
break;
}
return(true);
}
}
public ScriptRunner(ScriptDto scriptDto)
{
this.scriptDto = scriptDto;
}
public async Task <IActionResult> ValidateScript([FromBody] ScriptDto script)
{
ScriptValidationDto scriptValidation = await BotScript.ValidateScript(script.Script);
return(Ok(scriptValidation));
}
public void ListeningShortGeneration(InputDto inputDto, TemplateDto templateDto, ScriptDto scriptDto)
{
scriptDto.ListeningShort = string.Format(
templateDto.ListeningShortTemplate,
inputDto.Title,
inputDto.Lecture,
inputDto.Textus,
inputDto.FileName,
inputDto.PreachDate.Day.ToString());
}
public void ListeningLongGeneration(InputDto inputDto, TemplateDto templateDto, ScriptDto scriptDto)
{
scriptDto.ListeningLong = string.Format(
templateDto.ListeningLongTemplate,
inputDto.PreachDate.ToString("yyyy.MM.dd"),
inputDto.Lecture,
inputDto.Textus,
inputDto.FileName,
inputDto.Title,
inputDto.Preacher);
}
