public void Log(string content, int level = LogLevel.Information) { try { if (level == LogLevel.Information) { _logger.Info(content); } if (level == LogLevel.Debug) { _logger.Debug(content); } if (level == LogLevel.Error) { _logger.Error(content); } var logEntry = new ExecutionLog(); logEntry.LogContent = content; logEntry.LogLevel = level; logEntry.DateCreated = DateTime.UtcNow; Entities.ExecutionLogs.Add(logEntry); Entities.SaveChanges(); } catch (Exception ex) { // Swallow the exception! - this is a logger // _logger.Info($"Failed attempt to add Execution Log ({level}) {content}"); _logger.Error(ex); } }
public async Task <ApplicationUser> ProvisionNewAccount(string emailAddress, string domain) { var user = new ApplicationUser() { Email = emailAddress, UserName = emailAddress, }; using (var transaction = _dbContext.Database.BeginTransaction()) { var createUserResult = await _userManager.CreateAsync(user); if (!createUserResult.Succeeded) { _logger.Error( $"Unable to create new User for {user.Email}/{user.UserName} - " + $"{createUserResult.Errors.ToCommaDelimited()}"); return(null); } _logger.Info($"Created new User {user.Email}"); var addToRoleResult = await _userManager.AddToRoleAsync(user.Id, SecurityConfig.UserRole); if (!addToRoleResult.Succeeded) { _logger.Error( $"Unable to add User {user.Email}/{user.UserName} to {SecurityConfig.UserRole} - " + $"{createUserResult.Errors.ToCommaDelimited()}"); return(null); } _logger.Info($"Added User {user.Email} to Role {SecurityConfig.UserRole}"); var login = new UserLoginInfo("Shopify", domain); var addLoginResult = await _userManager.AddLoginAsync(user.Id, login); if (!addLoginResult.Succeeded) { _logger.Error( $"Unable to add Login for User {user.Email}/{user.UserName} - " + $"{addLoginResult.Errors.StringJoin(";")}"); return(null); } _logger.Info($"Added User {user.Email} Login {login.LoginProvider} / {login.ProviderKey}"); transaction.Commit(); } return(user); }
private void ProcessOrderAux(long shopifyOrderId) { try { ProcessOrder(shopifyOrderId); } catch (Exception ex) { _systemLogger.Error(ex); _logService.Log($"Encounter error syncing Payments for Shopify Order {shopifyOrderId}"); _syncOrderRepository.IncreaseOrderErrorCount(shopifyOrderId); } }
public void OrderSyncInChildScope(ConcurrentQueue <long> queue) { // NOTE: it's necessary to catch Exceptions, because this is running in its own thread try { var instanceId = _connectionContext.InstanceId; var monitorId = _monitoringService.CurrentScopeMonitorId; using (var childScope = _lifetimeScope.BeginLifetimeScope()) { var childConnectionContext = childScope.Resolve <InstanceContext>(); var childAcumaticaContext = childScope.Resolve <AcumaticaHttpContext>(); var childOrderSync = childScope.Resolve <AcumaticaOrderPut>(); var monitoringService = childScope.Resolve <JobMonitoringService>(); _logger.Debug( $"OrderSyncInChildScope - Acumatica Context: {childAcumaticaContext.ObjectIdentifier}"); childConnectionContext.Initialize(instanceId); monitoringService.RegisterCurrentScopeMonitorId(monitorId); childAcumaticaContext.SessionRun(() => childOrderSync.RunQueue(queue)); } } catch (Exception ex) { // NOTE => must do this, as an uncaught exception will bring the entire process down // _logger.Error(ex); } }
public bool Log(LogLevel logLevel, Func <string> messageFunc, Exception exception = null) { if (_logger == null) { return(false); } if (messageFunc == null && exception == null) { return(true); } if (logLevel == LogLevel.Trace && _logger.IsTraceEnabled) { _logger.Trace(messageFunc()); } if (logLevel == LogLevel.Debug && _logger.IsDebugEnabled) { _logger.Debug(messageFunc()); } if (logLevel == LogLevel.Info && _logger.IsInfoEnabled) { _logger.Info(messageFunc()); } if (logLevel == LogLevel.Warn && _logger.IsWarnEnabled) { _logger.Warn(messageFunc()); } if (logLevel == LogLevel.Error && _logger.IsErrorEnabled) { var message = messageFunc(); if (!message.IsNullOrEmpty()) { _logger.Error(message); } _logger.Error(exception); } if (logLevel == LogLevel.Fatal && _logger.IsFatalEnabled) { _logger.Fatal(messageFunc()); } return(true); }
public void TestConnection() { try { _executionLogService.Log("Connecting to Shopify..."); _orderApi.RetrieveCount(); _stateRepository.UpdateSystemState(x => x.ShopifyConnState, StateCode.Ok); } catch (Exception ex) { _logger.Error(ex); _stateRepository.UpdateSystemState(x => x.ShopifyConnState, StateCode.SystemFault); } }
public void Login() { try { var path = $"/entity/auth/login"; var content = _credentials.AuthenticationJson; var response = Post(path, content, excludeVersion: true); IsLoggedIn = true; } catch (Exception ex) { _logger.Error(ex); throw; } }
public void RunOrder(long shopifyOrderId) { try { CorrectSalesOrderWithUnknownRef(shopifyOrderId); // *** SAVE THIS, JONES! - This little branch of logic increases throughput!! // var orderPreAction = _pendingActionService.Create(shopifyOrderId).OrderAction; if (orderPreAction.ActionCode == ActionCode.UpdateInAcumatica && !orderPreAction.IsValid) { _acumaticaOrderPaymentPut.ProcessOrder(shopifyOrderId); } var orderAction = _pendingActionService.Create(shopifyOrderId).OrderAction; if (!orderAction.IsValid) { _logService.Log(LogBuilder.SkippingInvalidShopifyOrder(shopifyOrderId)); return; } if (orderAction.ActionCode == ActionCode.CreateInAcumatica) { CreateSalesOrder(shopifyOrderId); _acumaticaOrderPaymentPut.ProcessOrder(shopifyOrderId); return; } if (orderAction.ActionCode == ActionCode.UpdateInAcumatica) { _acumaticaOrderPaymentPut.ProcessOrder(shopifyOrderId); UpdateExistingSalesOrder(shopifyOrderId); return; } if (orderAction.ActionCode == ActionCode.CreateBlankSyncRecord) { CreateBlankSalesOrderRecord(shopifyOrderId); return; } } catch (Exception ex) { _systemLogger.Error(ex); _logService.Log($"Encountered error syncing Shopify Order {shopifyOrderId}"); _syncOrderRepository.IncreaseOrderErrorCount(shopifyOrderId); } }
private void PushFulfillmentToShopifyAux(AcumaticaSoShipment salesOrderShipment) { try { CorrectFulfillmentWithUnknownRef(salesOrderShipment.AcumaticaShipmentNbr); var syncReadiness = _fulfillmentStatusService.Validate(salesOrderShipment); if (syncReadiness.Success) { PushFulfillmentToShopify(salesOrderShipment.AcumaticaShipmentNbr); } } catch (Exception ex) { _pushLogger.Error(ex); _logService.Log($"Encounter error syncing {salesOrderShipment.LogDescriptor()}"); _syncOrderRepository .IncreaseOrderErrorCount(salesOrderShipment.AcumaticaSalesOrder.ShopifyOrder.ShopifyOrderId); throw; } }
private void ExecuteJob(Guid instanceId, Action action, long jobMonitorId) { _instanceContext.Initialize(instanceId); _jobMonitoringService.RegisterCurrentScopeMonitorId(jobMonitorId); var monitor = _jobMonitoringService.RetrieveCurrentScopeMonitor(); try { if (!InstanceLock.Acquire(instanceId.ToString())) { var msg = $"Failed to acquire lock '{InstanceLock.MethodName}'"; _executionLogService.Log(msg, LogLevel.Debug); return; } if (_jobMonitoringService.IsCorrupted(jobMonitorId)) { var msg = $"Job is missing or corrupted"; _executionLogService.Log(msg); _jobMonitoringService.CleanupPostExecution(jobMonitorId); InstanceLock.Free(instanceId.ToString()); return; } if (_jobMonitoringService.IsInterrupted(jobMonitorId)) { var msg = $"Job is missing or has received stop signal"; _executionLogService.Log(msg); _jobMonitoringService.CleanupPostExecution(jobMonitorId); InstanceLock.Free(instanceId.ToString()); return; } // Phew - we made it! Execute the requested task // _executionLogService.Log( BackgroundJobType.Name[monitor.BackgroundJobType] + " - starting"); action(); _jobMonitoringService.CleanupPostExecution(jobMonitorId); // *** IMPORTANT - do not refactor this to use-finally, else it will // ... break concurrency locking // InstanceLock.Free(instanceId.ToString()); } catch (Exception ex) { InstanceLock.Free(instanceId.ToString()); // If this is One-Time Job, this will remove the Monitor now that the Job has failed // _jobMonitoringService.CleanupPostExecution(jobMonitorId); _executionLogService.Log( BackgroundJobType.Name[monitor.BackgroundJobType] + " - encountered an error"); _logger.Error(ex); } finally { _executionLogService.Log( BackgroundJobType.Name[monitor.BackgroundJobType] + " - finished"); } }
// No [IdentityProcessor] attribute - the Identity will be dictated by "shop" i.e. domain // public ActionResult Return(string code, string shop, string returnUrl) { // Attempt to locate the identity, as there maybe a valid Domain + Access Token // This needs to happen before try-catch, else failure will make it attempt to // update using System State Repository // var userId = _provisioningService.RetrieveUserIdByShopifyDomain(shop); var identity = _identityService.HydrateIdentity(userId); if (!identity.IsAuthenticated) { throw new HttpException( (int)HttpStatusCode.Unauthorized, $"Attempt to login using invalid Shopify store {shop}"); } try { if (!VerifyShopifyHmac()) { throw new Exception("Failed HMAC verification from Shopify Return"); } if (BackButtonDetected(code)) { return(Redirect("Domain")); } // Get Key and Secret credentials from config file - and there is not Instance-specific. // var credentials = ShopifyCredentialsConfig.Settings.ToApiKeyAndSecret(shop); _shopifyHttpContext.Initialize(credentials); // Refresh the Shopify Access Token // var codeHash = _hmacCrypto.ToBase64EncodedSha256(code); var accessToken = _oAuthApi.RetrieveAccessToken(code, credentials); _connectionContext.UpdateShopifyCredentials(shop, accessToken, codeHash); // Issue ASP.NET sign-in cookie // _identityService.SignInAspNetUser(identity.AspNetUserId); HttpContext.SetIdentity(identity); if (identity.SystemState.IsRandomAccessMode) { return(Redirect(GlobalConfig.Url("/Sync/EndToEnd"))); } else { return(View(new ReturnModel { IsWizardMode = true, IsConnectionOk = true, })); } } catch (Exception ex) { _logger.Error(ex); _stateRepository.UpdateSystemState(x => x.ShopifyConnState, StateCode.SystemFault); throw; } }