public void PushBack()
{
CustomLogger.debug(this, "PushBack", CustomLogger.guardLog);
float halfAttackAngle = 90;
List <Transform> targets = new List <Transform> ();
foreach (Transform character in m_CharactersinRange)
{
if (character == null)
{
continue;
}
Vector3 lookDir = m_Body.forward;
lookDir.y = 0;
lookDir = lookDir.normalized;
Vector3 toTargetDir = (character.transform.position - this.transform.position);
toTargetDir.y = 0;
toTargetDir = toTargetDir.normalized;
float dotProd = Vector3.Dot(lookDir, toTargetDir);
if (dotProd >= 0 && halfAttackAngle >= (90 - 90 * dotProd))
{
targets.Add(character);
}
}
foreach (Transform target in targets)
{
CustomLogger.debug(this, "pushing : " + target.transform.name, CustomLogger.guardLog);
if (target == null)
{
continue;
}
target.transform.GetComponent <IDamageable> ().PushBack(this.transform.position);
}
}
public EmailNotificationResponse SendEmail(NotifyEmail notifyEmail)
{
if (EmailIsAnonymised(notifyEmail.EmailAddress))
{
return(null);
}
try
{
EmailNotificationResponse response = _client.SendEmail(
notifyEmail.EmailAddress,
notifyEmail.TemplateId,
notifyEmail.Personalisation);
return(response);
}
catch (NotifyClientException e)
{
CustomLogger.Error(
"EMAIL FAILURE: Error whilst sending email using Gov.UK Notify",
new {
NotifyEmail = notifyEmail,
Personalisation = JsonConvert.SerializeObject(notifyEmail.Personalisation),
ErrorMessageFromNotify = e.Message
});
throw;
}
}
public override void OnException(ExceptionContext context)
{
if (context.Exception is HttpException hex)
{
CustomLogger.Warning(hex.Message, hex);
context.Result = new ViewResult {
ViewName = "CustomError",
ViewData = new ViewDataDictionary(new EmptyModelMetadataProvider(), context.ModelState)
{
Model = new ErrorViewModel(hex.StatusCode) // set the model
}
};
context.ExceptionHandled = true;
}
else if (context.Exception is CustomErrorPageException customErrorPageException)
{
context.Result = new ViewResult
{
StatusCode = customErrorPageException.StatusCode,
ViewName = customErrorPageException.ViewName,
ViewData = new ViewDataDictionary(new EmptyModelMetadataProvider(), context.ModelState)
{
// For this type of custom error page, we use the exception itself as the model
Model = customErrorPageException
}
};
}
else if (context.Exception is CustomRedirectException customRedirectException)
{
context.Result = new RedirectResult(customRedirectException.RedirectUrl, permanent: false);
}
}
/// <summary>
/// constructor for Receipt controller
/// </summary>
/// <param name="receiptService"></param>
/// <param name="logger"></param>
public ReceiptController(
IReceiptService receiptService,
ILogger <ReceiptController> logger)
{
_logger = new CustomLogger <ReceiptController>(logger);
_service = (ReceiptService)receiptService;
}
[Obsolete("Please use method 'Employer' instead.")] //, true)]
public IActionResult EmployerDetails(string e = null, int y = 0, string id = null)
{
if (!string.IsNullOrWhiteSpace(id))
{
Organisation organisation;
try
{
CustomResult <Organisation> organisationLoadingOutcome =
OrganisationBusinessLogic.GetOrganisationByEncryptedReturnId(id);
if (organisationLoadingOutcome.Failed)
{
return(organisationLoadingOutcome.ErrorMessage.ToHttpStatusViewResult());
}
organisation = organisationLoadingOutcome.Result;
}
catch (Exception ex)
{
CustomLogger.Error("Cannot decrypt return id from query string", ex);
return(View("CustomError", new ErrorViewModel(400)));
}
string organisationIdEncrypted = organisation.GetEncryptedId();
return(RedirectToActionPermanent(nameof(Employer), new { employerIdentifier = organisationIdEncrypted }));
}
if (string.IsNullOrWhiteSpace(e))
{
return(new HttpBadRequestResult("EmployerDetails: \'e\' query parameter was null or white space"));
}
return(RedirectToActionPermanent(nameof(Employer), new { employerIdentifier = e }));
}
// instantiate a new UI object with a given prefab id, onto a specified layer
public UIObject CreateNewUIObject(string uiPrefabId, UILayerId layerId)
{
if (_activeUI.ContainsKey(uiPrefabId))
{
CustomLogger.Error(nameof(UIManager), $"Already contains active UI with prefab Id {uiPrefabId}!");
return(null);
}
if (!_uiLayers.TryGetValue(layerId, out UILayer layer))
{
CustomLogger.Error(nameof(UIManager), $"Layer Id {layerId} not found!");
return(null);
}
GameObject obj = AssetManager.Instance.GetAsset(uiPrefabId);
if (obj == null)
{
CustomLogger.Error(nameof(UIManager), $"Could not retrieve prefab for id {uiPrefabId}!");
return(null);
}
UIObject uiObject = obj.GetComponent <UIObject>();
if (uiObject == null)
{
CustomLogger.Error(nameof(UIManager), $"Prefab {uiPrefabId} did not contain type {nameof(UIObject)}!");
return(null);
}
UILayer parent = _uiLayers[layerId];
UIObject instancedUIObject = Instantiate(uiObject, _uiLayers[layerId].transform);
UIObjectEntry newEntry = new UIObjectEntry(layerId, instancedUIObject);
_activeUI.Add(uiPrefabId, newEntry);
CustomLogger.Log(nameof(UIManager), $"Creating ui object with prefab id {uiPrefabId}");
return(instancedUIObject);
}
/// <summary>
/// constructor for GateEntries controller
/// </summary>
/// <param name="gateEntriesService"></param>
/// <param name="logger"></param>
public GateEntriesController(
IGateEntriesService gateEntriesService,
ILogger <GateEntriesController> logger)
{
_logger = new CustomLogger <GateEntriesController>(logger);
_gateEntriesService = (GateEntriesService)gateEntriesService;
}
public static string SendEndSignal(string configUUID, string host_addr, CustomLogger clog)
{
// Create a request using a URL that can receive a post.
WebRequest analysisRequest = WebRequest.Create(host_addr);
analysisRequest.Method = "GET";
// Set the Config-GUID header
analysisRequest.Headers["Config-GUID"] = configUUID;
string analysisResponse = "[ProducerAzure] Default analysis response";
try
{
HttpWebResponse endResponse = (HttpWebResponse)analysisRequest.GetResponse();
if (endResponse.StatusCode != HttpStatusCode.OK)
{
clog.RawLog(LogLevel.ERROR, "[ProducerAzure] Bad consumer analysis status");
}
using (Stream responseStream = endResponse.GetResponseStream())
{
// Open the stream using a StreamReader for easy access and read the content
analysisResponse = new StreamReader(responseStream).ReadToEnd();
}
//analysisResponse = endResponse.StatusDescription;
endResponse.Close();
}
catch (WebException)
{
clog.RawLog(LogLevel.ERROR, "Got Web exception!");
}
return(analysisResponse);
}
public override Task ExecuteResultAsync(ActionContext actionContext)
{
string message;
if (Enum.IsDefined(typeof(HttpStatusCode), StatusCode.Value))
{
message = $"{(HttpStatusCode) StatusCode.Value} ({StatusCode.Value}): {StatusDescription}";
}
else
{
message = $"HttpStatusCode ({StatusCode.Value}): {StatusDescription}";
}
if (StatusCode == 404 || StatusCode == 405)
{
CustomLogger.Warning(message);
}
else if (StatusCode >= 500)
{
CustomLogger.Fatal(message);
}
else if (StatusCode >= 400)
{
CustomLogger.Error(message);
}
return(base.ExecuteResultAsync(actionContext));
}
/// <summary>
/// Force stops the research.
/// </summary>
public virtual void StopResearch()
{
currentManager.Cancel();
StatusInfo = new ResearchStatusInfo(ResearchStatus.Stopped, StatusInfo.CompletedStepsCount);
CustomLogger.Write("Research ID - " + ResearchID.ToString() +
". Research - " + ResearchName + ". STOPPED " + GetResearchType() + " RESEARCH.");
}
/// <summary>
/// Saves the results of research analyze.
/// </summary>
protected void SaveResearch()
{
if (result.EnsembleResults.Count == 0 || result.EnsembleResults[0] == null)
{
StatusInfo = new ResearchStatusInfo(ResearchStatus.Failed, StatusInfo.CompletedStepsCount + 1);
return;
}
result.ResearchID = ResearchID;
result.ResearchName = ResearchName;
result.ResearchType = GetResearchType();
result.ModelType = modelType;
result.RealizationCount = realizationCount;
result.Size = result.EnsembleResults[0].NetworkSize;
result.Edges = result.EnsembleResults[0].EdgesCount;
result.Date = DateTime.Now;
result.ResearchParameterValues = ResearchParameterValues;
result.GenerationParameterValues = GenerationParameterValues;
Storage.Save(result);
StatusInfo = new ResearchStatusInfo(ResearchStatus.Completed, StatusInfo.CompletedStepsCount + 1);
CustomLogger.Write("Research - " + ResearchName + ". Result is SAVED");
result.Clear();
CustomLogger.Write("Research - " + ResearchName + ". Result is CLEARED.");
}
public IActionResult ChangeAddressGet(long id)
{
Organisation organisation = dataRepository.Get <Organisation>(id);
if (!string.IsNullOrWhiteSpace(organisation.CompanyNumber))
{
try
{
CompaniesHouseCompany organisationFromCompaniesHouse =
companiesHouseApi.GetCompany(organisation.CompanyNumber);
OrganisationAddress addressFromCompaniesHouse =
UpdateFromCompaniesHouseService.CreateOrganisationAddressFromCompaniesHouseAddress(
organisationFromCompaniesHouse.RegisteredOfficeAddress);
if (!organisation.GetLatestAddress().AddressMatches(addressFromCompaniesHouse))
{
return(OfferNewCompaniesHouseAddress(organisation, addressFromCompaniesHouse));
}
}
catch (Exception ex)
{
// Use Manual Change page instead
CustomLogger.Warning("Error from Companies House API", ex);
}
}
// In all other cases...
// * Organisation doesn't have a Companies House number
// * CoHo API returns an error
// * CoHo address matches Organisation address
// ... send to the Manual Change page
return(SendToManualChangePage(organisation));
}
public IActionResult SendFeedbackPost(FeedbackViewModel viewModel)
{
viewModel.ParseAndValidateParameters(Request, m => m.HowEasyIsThisServiceToUse);
viewModel.ParseAndValidateParameters(Request, m => m.HowDidYouHearAboutGpg);
viewModel.ParseAndValidateParameters(Request, m => m.OtherSourceText);
viewModel.ParseAndValidateParameters(Request, m => m.WhyVisitGpgSite);
viewModel.ParseAndValidateParameters(Request, m => m.OtherReasonText);
viewModel.ParseAndValidateParameters(Request, m => m.WhoAreYou);
viewModel.ParseAndValidateParameters(Request, m => m.OtherPersonText);
viewModel.ParseAndValidateParameters(Request, m => m.Details);
if (viewModel.HasAnyErrors())
{
// If there are any errors, return the user back to the same page to correct the mistakes
return(View("SendFeedback", viewModel));
}
CustomLogger.Information("Feedback has been received", viewModel);
Feedback feedbackDatabaseModel = ConvertFeedbackViewModelIntoFeedbackDatabaseModel(viewModel);
dataRepository.Insert(feedbackDatabaseModel);
dataRepository.SaveChanges();
return(View("FeedbackSent"));
}
private void SetPathToTarget()
{
IntVector3 destination = GetClosestAvailableTile();
if (destination == _unit.MoveController.MapPosition)
{
CustomLogger.Warn(nameof(AIState_Chase), $"Could not find closest available tile!");
_unit.Navigator.OnArrivedFinalDestination -= OnArrivedFinalDestination;
SetReadyToTransition(_onFailedToPath);
}
PathStatus status = _unit.Navigator.SetDestination(
_unit.MoveController.MapPosition,
destination);
if (status == PathStatus.Invalid)
{
CustomLogger.Warn(nameof(AIState_Chase), $"Could not path to destination: {destination}!");
_unit.Navigator.OnArrivedFinalDestination -= OnArrivedFinalDestination;
SetReadyToTransition(_onFailedToPath);
return;
}
_unit.Navigator.OnArrivedFinalDestination += OnArrivedFinalDestination;
_unit.Navigator.LookTarget = null;
float speed = _fullSpeed ? _unit.UnitData.RunSpeed : _unit.UnitData.WalkSpeed;
_moveController.SetSpeed(speed);
}
public bool CheckConnected()
{
try
{
CustomLogger.Write("Research - " + ResearchName +
". CHECK CONNECTED STARTED for network - " + NetworkID.ToString());
bool result = false;
Debug.Assert(networkGenerator.Container != null);
networkAnalyzer.Container = networkGenerator.Container;
Object ccd = networkAnalyzer.CalculateOption(AnalyzeOption.ConnectedComponentDistribution);
Debug.Assert(ccd is SortedDictionary <Double, Double>);
SortedDictionary <Double, Double> r = ccd as SortedDictionary <Double, Double>;
result = r.ContainsKey(networkGenerator.Container.Size);
if (!result)
{
UpdateStatus(NetworkStatus.StepCompleted); // for analyze
}
CustomLogger.Write("Research - " + ResearchName +
". CHECK COMPLETED FINISHED for network - " + NetworkID.ToString());
return(result);
}
catch (CoreException ex)
{
UpdateStatus(NetworkStatus.Failed);
CustomLogger.Write("Research - " + ResearchName +
"CHECK COMPLETED FAILED for network - " + NetworkID.ToString() +
". Exception message: " + ex.Message);
return(false);
}
}
public override Task ExecuteResultAsync(ActionContext actionContext)
{
string message;
if (Enum.IsDefined(typeof(HttpStatusCode), StatusCode.Value))
{
message = $"{(HttpStatusCode)StatusCode.Value} ({StatusCode.Value}): {StatusDescription}";
}
else
{
message = $"HttpStatusCode ({StatusCode.Value}): {StatusDescription}";
}
if (StatusCode == 404 || StatusCode == 405)
{
CustomLogger.Warning(message);
}
else if (StatusCode >= 500)
{
CustomLogger.Fatal(message);
}
else if (StatusCode >= 400)
{
CustomLogger.Error(message);
}
ViewName = "Error";
ViewData = new ViewDataDictionary(new EmptyModelMetadataProvider(), actionContext.ModelState)
{
Model = new ErrorViewModel((int)StatusCode) // set the model
};
return(base.ExecuteResultAsync(actionContext));
}
public static bool TryParseAssetBundlePath(string assetName, out string filePath)
{
filePath = "";
string[] assetNameComponents = assetName.Split(AssetNameSplitter);
// this should be split into 2 parts
if (assetNameComponents.Length != 2)
{
CustomLogger.Error(nameof(IAssetManager), $"{assetName} is an invalid asset name!");
return(false);
}
string[] filePathComponents = assetNameComponents[0].Split(AssetBundlePathSplitter);
// file path components should be greater than 0
if (filePathComponents.Length == 0)
{
return(false);
}
filePath = filePathComponents[0];
for (int i = 1; i < filePathComponents.Length; i++)
{
string component = filePathComponents[i].ToLower();
filePath = $"{filePath}/{component}";
}
filePath = $"Assets/BundledResources/{filePath}";
return(true);
}
public async SystemTasks.Task TestCustomLogger()
{
CustomLogger logger = new CustomLogger();
Configuration config = Configuration.Create().WithVerbosityEnabled();
ICoyoteRuntime runtime = RuntimeFactory.Create(config);
runtime.SetLogger(logger);
Generator generator = Generator.Create();
Task task = Task.Run(() =>
{
int result = generator.NextInteger(10);
logger.WriteLine($"Task '{Task.CurrentId}' completed with result '{result}'.");
});
await task;
string expected = @"<RandomLog> Task '' nondeterministically chose ''. Task '' completed with result ''.";
string actual = RemoveNonDeterministicValuesFromReport(logger.ToString());
Assert.Equal(expected, actual);
logger.Dispose();
}
protected override void ValidateResearchParameters()
{
if (!ResearchParameterValues.ContainsKey(ResearchParameter.InputPath) ||
ResearchParameterValues[ResearchParameter.InputPath] == null ||
((MatrixPath)ResearchParameterValues[ResearchParameter.InputPath]).Path == "")
{
CustomLogger.Write("Research - " + ResearchName + ". Invalid research parameters.");
throw new InvalidResearchParameters();
}
MatrixPath mp = ((MatrixPath)ResearchParameterValues[ResearchParameter.InputPath]);
if ((File.GetAttributes(mp.Path) & FileAttributes.Directory) != FileAttributes.Directory)
{
CustomLogger.Write("Research - " + ResearchName + ". Invalid research parameters." +
" Directory should be specified.");
throw new InvalidResearchParameters();
}
if (Directory.GetFiles(mp.Path, "*.txt").Count() != 1)
{
CustomLogger.Write("Research - " + ResearchName + ". Invalid research parameters." +
" Directory should contain only 1 .txt file.");
throw new InvalidResearchParameters();
}
base.ValidateResearchParameters();
}
public bool Execute(IDictionary <string, object> parameters)
{
CustomLogger.Information("Get Fruits Step start");
CustomLogger.Information("Get Fruits Step Complete");
return(true);
}
static void Main(string[] args)
{
try
{
string configFileName = args[0];
CustomLogger.Information("Execution start");
CustomLogger.Information($"Loading Unity from File:{configFileName}");
IDictionary <string, object> parameters = new Dictionary <string, object> {
{ "CallCarrier", "false" },
{ "PackageFruits", "false" }
};
var container = _Bootstrapper(configFileName);
IWorkflowManager mgr = container.Resolve <IWorkflowManager>("SimpleWorkflowManager");
bool returnValue = mgr.Initiate(parameters);
}
catch (Exception ex)
{
CustomLogger.Exception(ex, "MAIN");
}
finally
{
Console.ReadKey();
CustomLogger.Information("Execution complete");
}
}
/// <summary>
/// Program entry point
/// </summary>
/// <param name="args">Passed arguments to program</param>
public static void Main(string[] args)
{
// Configuration application
var services = new ServiceCollection();
Startup.ConfigureServices(services);
var serviceProvider = services.BuildServiceProvider();
var logger = serviceProvider.GetService <ICustomLoggerFactory>().CreateLogger(typeof(Program).FullName);
// It just show how you can to use log event
logger.LogAdded += (o, e) => Console.WriteLine($"Getting log event with message: {e.Message}\n");
try
{
logger.Debug($"{Resource.ProgramStarted}: {DateTime.Now.ToLocalTime()}");
// Running application
serviceProvider.GetService <MainPage>().Display();
}
catch (Exception ex)
{
logger.Critical(ex.Message, ex);
}
finally
{
logger.Debug($"{Resource.ProgramFinished}: {DateTime.Now.ToLocalTime()}");
NLog.LogManager.Shutdown();
CustomLogger.ShutDown();
}
}
public bool TransitionToScene(string sceneName, bool requiresLoadingScreen)
{
Debug.Log($"Loading scene {sceneName}...");
if (_isLoadingScene)
{
CustomLogger.Warn(nameof(SceneController), $"Already loading scene {_nextSceneName}!");
return(false);
}
if (CurrentSceneName == sceneName)
{
CustomLogger.Log(nameof(SceneController), $"Already in scene {CurrentSceneName}!");
return(true);
}
_isLoadingScene = true;
_nextSceneName = sceneName;
if (requiresLoadingScreen)
{
LoadingScreenController.Instance.OnLoadingScreenShowComplete += OnEndSceneTransition;
LoadingScreenController.Instance.ShowLoadingScreen();
}
else
{
StartCoroutine(LoadSceneOneFrame());
}
return(true);
}
internal async Task <bool> DeleteDeckAsync(Deck deck)
{
try
{
HttpResponseMessage result = await _httpClient.DeleteAsync(new Uri(_deckUri, "decks/" + deck.DeckId));
return(result.IsSuccessStatusCode);
}
catch (HttpRequestException ex)
{
await CustomLogger.Log("DeleteDeckAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(false);
}
catch (InvalidOperationException ex)
{
await CustomLogger.Log("DeleteDeckAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(false);
}
catch (ArgumentNullException ex)
{
await CustomLogger.Log("DeleteDeckAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(false);
}
}
public async Task TestGraphLoggerCollapsed()
{
CustomLogger logger = new CustomLogger();
Configuration config = Configuration.Create().WithVerbosityEnabled();
var graphBuilder = new ActorRuntimeLogGraphBuilder(false);
graphBuilder.CollapseMachineInstances = true;
var tcs = TaskCompletionSource.Create <bool>();
IActorRuntime runtime = CreateTestRuntime(config, tcs, logger);
runtime.RegisterLog(graphBuilder);
ActorId serverId = runtime.CreateActor(typeof(Server));
runtime.CreateActor(typeof(Client), new ClientSetupEvent(serverId));
runtime.CreateActor(typeof(Client), new ClientSetupEvent(serverId));
runtime.CreateActor(typeof(Client), new ClientSetupEvent(serverId));
await WaitAsync(tcs.Task, 5000000);
await Task.Delay(1000);
string actual = graphBuilder.Graph.ToString();
Assert.Contains("<Node Id='Microsoft.Coyote.Production.Tests.Actors.CustomActorRuntimeLogTests+Client.Client' Label='Client'/>", actual);
Assert.Contains("<Node Id='Microsoft.Coyote.Production.Tests.Actors.CustomActorRuntimeLogTests+Server.Complete' Label='Complete'/>", actual);
logger.Dispose();
}
internal async Task <bool> EditDeckAsync(Deck deck)
{
try
{
var json = JsonConvert.SerializeObject(deck);
HttpResponseMessage result = await _httpClient.PutAsync(new Uri(_deckUri, "decks/" + deck.DeckId),
new StringContent(json, Encoding.UTF8, "application/json")).ConfigureAwait(true);
return(result.IsSuccessStatusCode);
}
catch (HttpRequestException ex)
{
await CustomLogger.Log("EditDeckAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(false);
}
catch (JsonReaderException ex)
{
await CustomLogger.Log("EditDeckAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(false);
}
catch (ArgumentNullException ex)
{
await CustomLogger.Log("EditDeckAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(false);
}
}
public CollectionController(IUserValidationService userValidationService, ICollectionService service, ILogger <ICategoryService> logger, IConfiguredProductService configuredProductService)
{
_collectionService = service;
_configuredProductService = configuredProductService;
_logger = new CustomLogger(logger);
_userValidationService = userValidationService;
}
public async Task <Deck[]> GetUserDecksAsync(int userId)
{
try
{
var clientResult = await _httpClient.GetAsync(_deckUri).ConfigureAwait(true);
var jsonData = await clientResult.Content.ReadAsStringAsync().ConfigureAwait(true);
Deck[] decks = JsonConvert.DeserializeObject <Deck[]>(jsonData);
return(decks.Where(x => x.UserId == userId).ToArray());
}
catch (HttpRequestException ex)
{
await CustomLogger.Log("GetUserDeckAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(null);
}
catch (ArgumentNullException ex)
{
await CustomLogger.Log("GetUserDeckAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(null);
}
}
public bool Execute(IDictionary <string, object> parameters)
{
CustomLogger.Information("Update Stock start");
CustomLogger.Information("Update Stock Complete");
return(true);
}
public override void StopActions()
{
CustomLogger.debug(this, "stop actions", CustomLogger.guardLog);
base.StopActions();
m_Attack = null;
m_Dash = null;
}
