/// <summary>
/// Initializes a new instance of the <see cref="WorkflowBase{TStatus, TActivity, TTask, TActor}"/> class.
/// </summary>
/// <param name="versionKey">Workflow instance version key</param>
/// <param name="statusObject">The loan application.</param>
/// <param name="actorProvider">The actor provider.</param>
protected WorkflowBase(string versionKey, IStateObject <TStatus> statusObject, IActorProvider <TActor> actorProvider)
{
versionKey
.ThrowIfNull("versionKey");
// Init object version if it is empty
if (String.IsNullOrWhiteSpace(statusObject.WorkflowVersionKey))
{
statusObject.WorkflowVersionKey = versionKey;
}
if (!versionKey.Equals(statusObject.WorkflowVersionKey))
{
throw new WrongWorkflowVersionException(statusObject.WorkflowVersionKey, versionKey);
}
VersionKey = versionKey;
StatusObject = statusObject;
_actorProvider = actorProvider;
Machine = new StateMachine <TStatus, TActivity>(
() => StatusObject.Status,
s => StatusObject.Status = s);
TaskRestrictionsByActor =
new Dictionary <TActor, RestrictionList <TStatus, TTask> >();
_triggersWithParameters =
new Dictionary <string, StateMachine <TStatus, TActivity> .TriggerWithParameters>();
Configure();
Machine
.OnTransitioned(LogTransition);
}
public PrivateApiController(
IActorProvider <SimulationActor> simulationActorProvider,
ILogger <PublicApiController> logger)
{
this.simulationActorRef = simulationActorProvider.Get();
this.logger = logger;
}
public EventProcessor(
IActorProvider <ProcessingCoordinatorActor> processingCoordinatorActorProvider,
IMapper mapper)
{
this.processingCoordinatorActor = processingCoordinatorActorProvider.Get();
this.mapper = mapper;
}
protected SimpleAuditDbContext(DbContextOptions options, IActorProvider <T> actorProvider, IClock clock)
: base(options)
{
_auditor = new Auditor(ChangeTracker);
_actorProvider = actorProvider;
_clock = clock;
}
public DataManager(IActorProvider actorProvider, IUserProvider userProvider, IFilmProvider filmProvider, IDirectorProvider directorProvider, IPrizeProvider prizeProvider)
{
this._actorProvider = actorProvider;
this._userProvider = userProvider;
this._filmProvider = filmProvider;
this._directorProvider = directorProvider;
this._prizeProvider = prizeProvider;
}
public ActorUnderTest(
IActorProvider <HttpRequestActor> httpRequestActorProvider,
IOptions <ServiceSettings> serviceSettings,
TestProbe parentTestProbe)
: base(httpRequestActorProvider, serviceSettings)
{
this.parentTestProbe = parentTestProbe;
}
public CompetitionOpenedStateMachineConfigurator(IActorProvider actorProvider)
{
if (actorProvider == null)
{
throw new ArgumentNullException(nameof(actorProvider));
}
_actorProvider = actorProvider;
}
public WarehouseSendActor(
IActorProvider <HttpRequestActor> httpRequestActorProvider,
IOptions <ServiceSettings> serviceSettings)
{
this.httpRequestActor = httpRequestActorProvider.Get();
this.serviceSettings = serviceSettings.Value;
Receive <Models.WarehouseOrderModel>(Handle);
}
public PrivateApiController(
IActorProvider <PrinterActor> printerActorProvider,
ILogger <PrivateApiController> logger,
IMapper mapper)
{
this.printerActorRef = printerActorProvider.Get();
this.logger = logger;
this.mapper = mapper;
}
public ExternalOrderProcessor(
IActorProvider <HttpRequestActor> httpRequestActorProvider,
IOptions <ServiceSettings> serviceSettings,
IMapper mapper)
{
this.httpRequestActor = httpRequestActorProvider.Get();
this.serviceSettings = serviceSettings.Value;
this.mapper = mapper;
}
public PublicApiController(
IActorProvider <OrderActor> orderActorProvider,
ILogger <PublicApiController> logger,
IMapper mapper)
{
this.orderActorRef = orderActorProvider.Get();
this.logger = logger;
this.mapper = mapper;
}
public static IActor ExtractActor(object obj)
{
IActorProvider provider = obj as IActorProvider;
if (provider == null)
{
return(null);
}
return(provider.GetActor());
}
public ActorsModule(IActorProvider actorProvider)
{
this.Get("/actors", async(req, res, routeData) =>
{
var people = actorProvider.Get();
await res.AsJson(people);
});
this.Get("/actors/{id:int}", async(req, res, routeData) =>
{
var person = actorProvider.Get(routeData.As <int>("id"));
await res.Negotiate(person);
});
this.Put("/actors/{id:int}", async(req, res, routeData) =>
{
var result = req.BindAndValidate <Actor>();
if (!result.ValidationResult.IsValid)
{
res.StatusCode = 422;
await res.Negotiate(result.ValidationResult.GetFormattedErrors());
return;
}
//Update the user in your database
res.StatusCode = 204;
});
this.Post("/actors", async(req, res, routeData) =>
{
var result = req.BindAndValidate <Actor>();
if (!result.ValidationResult.IsValid)
{
res.StatusCode = 422;
await res.Negotiate(result.ValidationResult.GetFormattedErrors());
return;
}
//Save the user in your database
res.StatusCode = 201;
await res.Negotiate(result.Data);
});
this.Get("/actors/download", async(request, response, routeData) =>
{
using (var video = new FileStream("earth.mp4", FileMode.Open)) //24406813
{
await response.FromStream(video, "video/mp4");
}
});
}
public ProcessingUnitActor(
IActorProvider <HttpRequestActor> httpRequestActorProvider,
IOptions <ServiceSettings> serviceSettings,
IMapper mapper)
{
this.httpRequestActor = httpRequestActorProvider.Get();
this.serviceSettings = serviceSettings.Value;
this.mapper = mapper;
Receive <StartProcessing>(Handle);
}
private void MoveAsRay(float delta)
{
Transform t = GlobalTransform;
Vector3 origin = t.origin;
Vector3 forward = -t.basis.z;
Vector3 dest = origin;
dest += (forward * _def.launchSpeed) * delta;
uint mask = uint.MaxValue;
PhysicsDirectSpaceState space = GetWorld().DirectSpaceState;
Godot.Collections.Array arr = null;
if (_ignoreBody != null)
{
arr = new Godot.Collections.Array();
arr.Add(_ignoreBody);
}
Dictionary hitResult = space.IntersectRay(origin, dest, arr, mask);
if (hitResult.Keys.Count > 0)
{
_touch.damage = _def.damage;
_touch.teamId = 0;
_touch.touchType = TouchType.Bullet;
IActorProvider actorProvider = hitResult["collider"] as IActorProvider;
if (actorProvider != null)
{
IActor actor = actorProvider.GetActor();
if (actor != null)
{
TouchResponseData response = actor.ActorTouch(_touch);
Console.WriteLine($"Prj hit actor for {response.damageTaken}");
}
else
{
Console.WriteLine($"Prj hit provider but actor is null!");
}
}
else
{
//Node hitObj = (hitResult["collider"] as Node);
//Console.WriteLine($"Prj hit non-actor node {hitObj.Name}");
}
Vector3 gfxOrigin = (Vector3)hitResult["position"];
GFXQuick gfx = Main.i.factory.SpawnGFX(GameFactory.Path_GFXImpact);
gfx.Spawn(gfxOrigin);
Die();
return;
}
t.origin = dest;
GlobalTransform = t;
}
public ActorTask(
IJsonSerializationService jsonSerializationService,
IActorProvider <TActor> fundingActorProvider,
IKeyValuePersistenceService keyValuePersistenceService,
IFundingOutputCondenserService <TActorReturn> fundingOutputCondenserService,
ILogger logger,
string actorName)
{
_jsonSerializationService = jsonSerializationService;
_fundingActorProvider = fundingActorProvider;
_keyValuePersistenceService = keyValuePersistenceService;
_fundingOutputCondenserService = fundingOutputCondenserService;
_logger = logger;
_actorName = actorName;
}
public FM70ActorTask(
IJsonSerializationService jsonSerializationService,
IActorProvider <IFM70Actor> fundingActorProvider,
IFilePersistanceService filePersistanceService,
IFundingOutputCondenserService <FM70Global> fundingOutputCondenserService,
ILogger logger,
string actorName)
{
_jsonSerializationService = jsonSerializationService;
_fundingActorProvider = fundingActorProvider;
_filePersistanceService = filePersistanceService;
_fundingOutputCondenserService = fundingOutputCondenserService;
_logger = logger;
_actorName = actorName;
}
public CompetitionOnModerationStateMachineConfigurator(IUserPrincipalProvider userPrincipalProvider,
IActorProvider actorProvider)
{
if (userPrincipalProvider == null)
{
throw new ArgumentNullException(nameof(userPrincipalProvider));
}
if (actorProvider == null)
{
throw new ArgumentNullException(nameof(actorProvider));
}
_userPrincipalProvider = userPrincipalProvider;
_actorProvider = actorProvider;
}
private PrivateApiControllerSpec()
{
progProductActor = Kit.CreateProgrammableActor <ProductActor>("product-actor");
IActorProvider <ProductActor> productActorProvider = An <IActorProvider <ProductActor> >();
productActorProvider.Get().Returns(progProductActor.TestProbe);
var config = new MapperConfiguration(cfg => cfg.AddProfile(new ProductMapping()));
config.AssertConfigurationIsValid();
Subject = new PrivateApiController(
productActorProvider,
An <ILogger <PrivateApiController> >(),
config.CreateMapper());
}
private PublicApiControllerSpec()
{
progOrderActor = Kit.CreateProgrammableActor <OrderActor>("order-actor");
IActorProvider <OrderActor> orderActorProvider = An <IActorProvider <OrderActor> >();
orderActorProvider.Get().Returns(progOrderActor.TestProbe);
var config = new MapperConfiguration(cfg => cfg.AddProfile(new OrderMapping()));
config.AssertConfigurationIsValid();
Subject = new PublicApiController(
orderActorProvider,
An <ILogger <PublicApiController> >(),
config.CreateMapper());
}
private ALBActorTask NewTask(
IJsonSerializationService jsonSerializationService = null,
IActorProvider <IALBActor> fundingActorProvider = null,
IFilePersistanceService filePersistanceService = null,
IFundingOutputCondenserService <ALBGlobal> fundingOutputCondenserService = null,
ILogger logger = null,
string actorName = null)
{
return(new ALBActorTask(
jsonSerializationService,
fundingActorProvider,
filePersistanceService,
fundingOutputCondenserService,
logger,
actorName));
}
public ActorsModule(IActorProvider actorProvider)
{
this.Get("/actors", async(req, res, routeData) =>
{
var people = actorProvider.Get();
await res.AsJson(people);
});
this.Get("/actors/{id:int}", async(req, res, routeData) =>
{
var person = actorProvider.Get(routeData.AsInt("id"));
await res.Negotiate(person);
});
this.Put("/actors/{id:int}", async(req, res, routeData) =>
{
var result = req.BindAndValidate <Actor>();
if (!result.ValidationResult.IsValid)
{
res.StatusCode = 422;
await res.Negotiate(result.ValidationResult.GetFormattedErrors());
return;
}
//Update the user in your database
res.StatusCode = 204;
});
this.Post("/actors", async(req, res, routeData) =>
{
var result = req.BindAndValidate <Actor>();
if (!result.ValidationResult.IsValid)
{
res.StatusCode = 422;
await res.Negotiate(result.ValidationResult.GetFormattedErrors());
return;
}
//Save the user in your database
res.StatusCode = 201;
await res.Negotiate(result.Data);
});
}
public void Initiate(ICurrencyProvider currencyProvider, IActorProvider actorProvider)
{
Console.WriteLine("!! Actor Manger initiate...");
ActorProvider = actorProvider;
CurrencyProvider = currencyProvider;
ActorFactory = new ActorFactory(actorProvider);
Console.WriteLine("!!Spawn first generation...");
// Проверки систем
// запуск акторов
SpawnGeneration(); // нулевое поколение
this.ManagerTask = new Task(() =>
{
Console.WriteLine("!! Actor manger main task started");
while (true)
{
if (this.managerMainCancelTokenSource.IsCancellationRequested)
{
return;
}
AllActors.RemoveAll(x => !x.Data.IsAlive);
if (AllActors.Count == 0)
{
break;
}
if (LastGeneration > 0 && AllActors.Any(x => x.Data.Generation == LastGeneration && x.Data.CurrentTime - Const.StartActorTime > Const.NewGenerationSpawnDelay))
{
var oldActorsCount = AllActors.Count;
SpawnGeneration();
Console.WriteLine($"!! New generation spawned; Added actors: {AllActors.Count - oldActorsCount}");
}
//Thread.Sleep(1000);
}
Console.WriteLine("!! All actors are dead");
});
this.ManagerTask.Start();
this.IsInitiated = true;
}
public void ApplyAudit <T>(
bool applyTimeAudit,
bool applyActorAudit,
IClock clock = null,
IActorProvider <T> actorProvider = null)
where T : struct
{
var auditableEntityEntries = _changeTracker.Entries <IBaseSimpleAuditEntity>();
foreach (var entry in auditableEntityEntries)
{
if (applyTimeAudit)
{
ApplyTimeAudit(entry, clock);
}
if (applyActorAudit)
{
ApplyActorAudit(entry, actorProvider);
}
}
}
private void ApplyActorAudit <T>(EntityEntry <IBaseSimpleAuditEntity> entry, IActorProvider <T> actorProvider)
where T : struct
{
if (actorProvider == null)
{
throw new ArgumentNullException(nameof(actorProvider));
}
if (!(entry.Entity is ISimpleActorAuditEntity <T> simpleTimeAuditEntity))
{
return;
}
switch (entry.State)
{
case EntityState.Added:
simpleTimeAuditEntity.CreatedBy = actorProvider.Provide();
break;
case EntityState.Modified:
simpleTimeAuditEntity.LastModifiedBy = actorProvider.Provide();
break;
}
}
public ActorProviderHolder(IActorProvider <TActor> provider)
{
Provider = provider;
}
public ActorModule(IActorProvider actorProvider)
{
Get("/actors", (req, res) =>
{
var actors = actorProvider.Get();
return(res.Negotiate(actors));
});
Get("/actors/{id:int}", (req, res) =>
{
try
{
var actor = actorProvider.Get(req.RouteValues.As <int>("id"));
return(res.Negotiate(actor));
}
catch (KeyNotFoundException)
{
res.StatusCode = 404;
return(Task.CompletedTask);
}
});
Post("/actors", async(req, res) =>
{
var result = await req.BindAndValidate <Actor>();
if (!result.ValidationResult.IsValid)
{
res.StatusCode = 422;
await res.Negotiate(result.ValidationResult.GetFormattedErrors());
return;
}
var actor = actorProvider.Create(result.Data);
res.StatusCode = 201;
await res.Negotiate(actor);
});
Put("/actors/{id:int}", async(req, res) =>
{
var result = await req.BindAndValidate <Actor>();
if (!result.ValidationResult.IsValid)
{
res.StatusCode = 422;
await res.Negotiate(result.ValidationResult.GetFormattedErrors());
return;
}
result.Data.Id = req.RouteValues.As <int>("id");
actorProvider.Update(result.Data);
res.StatusCode = 204;
});
Post("/actors/{id:int}/avatar", async(req, res) =>
{
try
{
var actor = actorProvider.Get(req.RouteValues.As <int>("id"));
var file = await req.BindFile();
actor.Avatar = file.FileName;
actorProvider.Update(actor);
await res.Negotiate(actor);
}
catch (KeyNotFoundException)
{
res.StatusCode = 404;
}
});
Delete("/actors/{id:int}", (req, res) =>
{
actorProvider.Delete(req.RouteValues.As <int>("id"));
res.StatusCode = 204;
return(Task.CompletedTask);
});
}
public ControllerBootstraper(IActorProvider actorProvider, ILifetimeScope scope)
{
ActorProvider = actorProvider;
Scope = scope;
}
public AuditDbContext(DbContextOptions options, IActorProvider <int> actorProvider)
: base(options, actorProvider)
{
}
public ActorsModule(IActorProvider actorProvider)
{
this.Get <GetActors>("/actors", (req, res, routeData) =>
{
var people = actorProvider.Get();
return(res.AsJson(people));
});
this.Get <GetActorById>("/actors/{id:int}", (req, res, routeData) =>
{
var person = actorProvider.Get(routeData.As <int>("id"));
return(res.Negotiate(person));
});
this.Put <UpdateActor>("/actors/{id:int}", async(req, res, routeData) =>
{
var result = req.BindAndValidate <Actor>();
if (!result.ValidationResult.IsValid)
{
res.StatusCode = 422;
await res.Negotiate(result.ValidationResult.GetFormattedErrors());
return;
}
//Update the user in your database
res.StatusCode = 204;
});
this.Post <AddActor>("/actors", async(req, res, routeData) =>
{
var result = req.BindAndValidate <Actor>();
if (!result.ValidationResult.IsValid)
{
res.StatusCode = 422;
await res.Negotiate(result.ValidationResult.GetFormattedErrors());
return;
}
//Save the user in your database
res.StatusCode = 201;
await res.Negotiate(result.Data);
});
this.Delete <DeleteActor>("/actors/{id:int}", (req, res, routeData) =>
{
actorProvider.Delete(routeData.As <int>("id"));
res.StatusCode = 204;
return(Task.CompletedTask);
});
this.Get("/actors/download", async(request, response, routeData) =>
{
using (var video = new FileStream("earth.mp4", FileMode.Open)) //24406813
{
await response.FromStream(video, "video/mp4");
}
});
this.Get <EmptyOpenApiMetaData>("/empty", (request, response, routeData) => Task.CompletedTask);
this.Get <SampleMetaData>("/actors/sample", (request, response, routeData) => Task.CompletedTask);
this.Post <NoValidatorMetaData>("/actors/sample", (request, response, routeData) => Task.CompletedTask);
}
