public IActionResult Post([FromBody] CreateProcessViewModel createProcessViewModel)
{
return(ApiAction(() =>
{
var contract = _mapper.Map <CreateProcessContract>(createProcessViewModel);
var returnContract = _processService.Create(contract);
return Created("Get", _mapper.Map <CreatedProcessViewModel>(returnContract));
}));
}
private async ValueTask <AccessToken> RequestCliAccessTokenAsync(bool async, TokenRequestContext context, CancellationToken cancellationToken)
{
string resource = ScopeUtilities.ScopesToResource(context.Scopes);
string tenantId = TenantIdResolver.Resolve(_tenantId, context, _allowMultiTenantAuthentication);
ScopeUtilities.ValidateScope(resource);
GetFileNameAndArguments(resource, tenantId, out string fileName, out string argument);
ProcessStartInfo processStartInfo = GetAzureCliProcessStartInfo(fileName, argument);
using var processRunner = new ProcessRunner(_processService.Create(processStartInfo), TimeSpan.FromMilliseconds(CliProcessTimeoutMs), cancellationToken);
string output;
try
{
output = async ? await processRunner.RunAsync().ConfigureAwait(false) : processRunner.Run();
}
catch (OperationCanceledException) when(!cancellationToken.IsCancellationRequested)
{
throw new AuthenticationFailedException(AzureCliTimeoutError);
}
catch (InvalidOperationException exception)
{
bool isWinError = exception.Message.StartsWith(WinAzureCLIError, StringComparison.CurrentCultureIgnoreCase);
bool isOtherOsError = AzNotFoundPattern.IsMatch(exception.Message);
if (isWinError || isOtherOsError)
{
throw new CredentialUnavailableException(AzureCLINotInstalled);
}
bool isLoginError = exception.Message.IndexOf("az login", StringComparison.OrdinalIgnoreCase) != -1 ||
exception.Message.IndexOf("az account set", StringComparison.OrdinalIgnoreCase) != -1;
if (isLoginError)
{
throw new CredentialUnavailableException(AzNotLogIn);
}
bool isRefreshTokenFailedError = exception.Message.IndexOf(AzureCliFailedError, StringComparison.OrdinalIgnoreCase) != -1 &&
exception.Message.IndexOf(RefreshTokeExpired, StringComparison.OrdinalIgnoreCase) != -1 ||
exception.Message.IndexOf("CLIInternalError", StringComparison.OrdinalIgnoreCase) != -1;
if (isRefreshTokenFailedError)
{
throw new CredentialUnavailableException(InteractiveLoginRequired);
}
throw new AuthenticationFailedException($"{AzureCliFailedError} {exception.Message}");
}
return(DeserializeOutput(output));
}
public CreatedResult CreateProcess()
{
Guid processIdentifier = Guid.Empty;
if (HttpContext.Request.Form.Files.Any())
{
foreach (var file in HttpContext.Request.Form.Files)
{
processIdentifier = processService.Create(file.OpenReadStream());
}
}
return(Created("", processIdentifier));
}
private async ValueTask <AccessToken> RequestAzurePowerShellAccessTokenAsync(bool async, TokenRequestContext context, CancellationToken cancellationToken)
{
string resource = ScopeUtilities.ScopesToResource(context.Scopes);
ScopeUtilities.ValidateScope(resource);
var tenantId = TenantIdResolver.Resolve(_tenantId, context, _allowMultiTenantAuthentication);
GetFileNameAndArguments(resource, tenantId, out string fileName, out string argument);
ProcessStartInfo processStartInfo = GetAzurePowerShellProcessStartInfo(fileName, argument);
using var processRunner = new ProcessRunner(
_processService.Create(processStartInfo),
TimeSpan.FromMilliseconds(PowerShellProcessTimeoutMs),
_logPII,
cancellationToken);
string output;
try
{
output = async ? await processRunner.RunAsync().ConfigureAwait(false) : processRunner.Run();
CheckForErrors(output);
}
catch (OperationCanceledException) when(!cancellationToken.IsCancellationRequested)
{
throw new AuthenticationFailedException(AzurePowerShellTimeoutError);
}
catch (InvalidOperationException exception)
{
bool noPowerShell = exception.Message.IndexOf("not found", StringComparison.OrdinalIgnoreCase) != -1 ||
exception.Message.IndexOf("is not recognized", StringComparison.OrdinalIgnoreCase) != -1;
if (noPowerShell)
{
throw new CredentialUnavailableException(PowerShellNotInstalledError);
}
bool noLogin = exception.Message.IndexOf("Run Connect-AzAccount to login", StringComparison.OrdinalIgnoreCase) != -1;
if (noLogin)
{
throw new CredentialUnavailableException(AzurePowerShellNotLogInError);
}
throw new AuthenticationFailedException($"{AzurePowerShellFailedError} {exception.Message}");
}
return(DeserializeOutput(output));
}
/// <summary>
/// Run log file processing
/// </summary>
public void Run()
{
BulkHelper <EventData> blkHelper = new BulkHelper <EventData>("logs" + DateTime.UtcNow.ToString("YYYYMMddHHmmss"), new LiteDbService(_logger), _logger);
using (FileStream fs = File.Open(_filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.Read))
using (StreamReader sr = new StreamReader(fs))
{
Dictionary <string, LogLine> lines = new Dictionary <string, LogLine>();
string line;
while ((line = sr.ReadLine()) != null)
{
LogLine currentLine = _convertService.ToObject(line);
LogLine logLine;
if (lines.TryGetValue(currentLine.Id, out logLine))
{
EventData eventData = _processService.Create(currentLine, logLine);
if (eventData == null)
{
continue;
}
blkHelper.QueueInsert(eventData);
lines.Remove(currentLine.Id);
}
else
{
lines.Add(currentLine.Id, currentLine);
}
}
blkHelper.QueuePush();
}
_logger.Info($"File processed.");
}
private async ValueTask <AccessToken> RequestAzurePowerShellAccessTokenAsync(bool async, TokenRequestContext context, CancellationToken cancellationToken)
{
string resource = ScopeUtilities.ScopesToResource(context.Scopes);
ScopeUtilities.ValidateScope(resource);
var tenantId = TenantIdResolver.Resolve(_tenantId, context);
GetFileNameAndArguments(resource, tenantId, out string fileName, out string argument);
ProcessStartInfo processStartInfo = GetAzurePowerShellProcessStartInfo(fileName, argument);
using var processRunner = new ProcessRunner(
_processService.Create(processStartInfo),
TimeSpan.FromMilliseconds(PowerShellProcessTimeoutMs),
_logPII,
cancellationToken);
string output;
try
{
output = async ? await processRunner.RunAsync().ConfigureAwait(false) : processRunner.Run();
CheckForErrors(output);
ValidateResult(output);
}
catch (OperationCanceledException) when(!cancellationToken.IsCancellationRequested)
{
throw new AuthenticationFailedException(AzurePowerShellTimeoutError);
}
catch (InvalidOperationException exception)
{
CheckForErrors(exception.Message);
throw new AuthenticationFailedException($"{AzurePowerShellFailedError} {exception.Message}");
}
return(DeserializeOutput(output));
}
public ActionResult Create(Process vm)
{
Process pt = vm;
if (ModelState.IsValid)
{
if (vm.ProcessId == 0)
{
pt.CreatedDate = DateTime.Now;
pt.ModifiedDate = DateTime.Now;
pt.CreatedBy = User.Identity.Name;
pt.ModifiedBy = User.Identity.Name;
pt.ObjectState = Model.ObjectState.Added;
_ProcessService.Create(pt);
try
{
_unitOfWork.Save();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
ModelState.AddModelError("", message);
return(View("Create", vm));
}
LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
{
DocTypeId = new DocumentTypeService(_unitOfWork).FindByName(MasterDocTypeConstants.Process).DocumentTypeId,
DocId = pt.ProcessId,
ActivityType = (int)ActivityTypeContants.Added,
}));
return(RedirectToAction("Create").Success("Data saved successfully"));
}
else
{
List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();
Process temp = _ProcessService.Find(pt.ProcessId);
Process ExRec = Mapper.Map <Process>(temp);
temp.ProcessName = pt.ProcessName;
temp.ProcessCode = pt.ProcessCode;
temp.ParentProcessId = pt.ParentProcessId;
temp.AccountId = pt.AccountId;
temp.IsActive = pt.IsActive;
temp.IsSystemDefine = pt.IsSystemDefine;
temp.IsAffectedStock = pt.IsAffectedStock;
temp.ModifiedDate = DateTime.Now;
temp.ModifiedBy = User.Identity.Name;
temp.ObjectState = Model.ObjectState.Modified;
_ProcessService.Update(temp);
LogList.Add(new LogTypeViewModel
{
ExObj = ExRec,
Obj = temp,
});
XElement Modifications = new ModificationsCheckService().CheckChanges(LogList);
try
{
_unitOfWork.Save();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
ModelState.AddModelError("", message);
return(View("Create", pt));
}
LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
{
DocTypeId = new DocumentTypeService(_unitOfWork).FindByName(MasterDocTypeConstants.Process).DocumentTypeId,
DocId = temp.ProcessId,
ActivityType = (int)ActivityTypeContants.Modified,
xEModifications = Modifications,
}));
return(RedirectToAction("Index").Success("Data saved successfully"));
}
}
return(View(vm));
}