public override DeployActionUnitResponse ExecuteDeploy(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
var cloneRepositoryFolderDependency = GetDependencyFromSameSource <CreateDomainSolutionFile>
(sourceActionExecution, currentExecutionDeployActions);
var solutionPathParameter = DeployResponseParametersDefinitions.MicroServices.CreateSolutionFile.Path;
var solutionPath = cloneRepositoryFolderDependency.ResponseParameters[solutionPathParameter] as string;
var projectFolderName = $"{projectState.NameSpace}.{projectState.Name}.Domain";
var completeFolder = FileService.ConcatDirectoryAndFileOrFolder(solutionPath, projectFolderName);
var exisistsFolder = FileService.ExistsFolder(completeFolder);
if (!exisistsFolder)
{
FileService.CreateFolder(completeFolder);
}
return(new DeployActionUnitResponse()
.Ok(GetResponseParameters(completeFolder), DeployActionUnitResponse.DeployActionResponseType.AlreadyCompletedJob));
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
public override DeployActionUnitResponse ExecuteDeploy(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
var createRepositoryFolderDependency = GetDependencyFromSameSource <CreateRepositoriesFolder>(sourceActionExecution, currentExecutionDeployActions);
var createGithubRepositoryDependency = GetDependencyFromSameSource <CreateGithubRepository>(sourceActionExecution, currentExecutionDeployActions);
var pathParameter = DeployResponseParametersDefinitions.Project.CreateRepositoriesFolder.RepositoryPath;
var repositoriesPath = createRepositoryFolderDependency.ResponseParameters[pathParameter] as string;
var repositorySvnUrl = DeployResponseParametersDefinitions.MicroServices.CreateGithubRepository.SvnUrl;
var repositoryNameParameter = DeployResponseParametersDefinitions.MicroServices.CreateGithubRepository.Name;
var repositoryName = createGithubRepositoryDependency.ResponseParameters[repositoryNameParameter] as string;
var path = FileService.ConcatDirectoryAndFileOrFolder(repositoriesPath, repositoryName);
var repositoryUrl = createGithubRepositoryDependency.ResponseParameters[repositorySvnUrl] as string;
var settingGit = GetSetting(projectState, SettingsDefinitions.GitExePath);
GitClientService.Initialize(settingGit);
var repositoryPath = FileService.ConcatDirectoryAndFileOrFolder(repositoriesPath, repositoryName);
if (FileService.ExistsFolder(repositoryPath))
{
FileService.DeleteFolder(repositoryPath);
}
GitClientService.CloneRepository(repositoriesPath, repositoryUrl);
return(new DeployActionUnitResponse()
.Ok(GetParameters(path)));
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
public CleanRepositoryFolder(
ActionExecution actionExecution,
IFileService fileService)
: base(actionExecution, ActionName, ActionDescription, DeployManager.Phases.AvailableInfrastructure, Positions.First, Positions.Fifth)
{
FileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
}
public override DeployActionUnitResponse ExecuteCheck(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
var baseFolder = projectState.Path;
if (string.IsNullOrEmpty(baseFolder))
{
throw new Exception("Project path folder undefined");
}
var completeRepositoriesName = $"{projectState.Name}\\{Definitions.DeployDefinitions.RepositoriesFolderName}";
var repositoriesFolder = FileService.ConcatDirectoryAndFileOrFolder(baseFolder, completeRepositoriesName);
var completeTempName = $"{projectState.Name}\\{Definitions.DeployDefinitions.TempFolderName}";
var tempFolder = FileService.ConcatDirectoryAndFileOrFolder(baseFolder, completeTempName);
var existsRepositoriesFolder = FileService.ExistsFolder(repositoriesFolder) && FileService.ExistsFolder(tempFolder);
return(existsRepositoriesFolder
? new DeployActionUnitResponse()
.Ok(GetResponseParameters(repositoriesFolder, tempFolder), DeployActionUnitResponse.DeployActionResponseType.AlreadyCompletedJob)
: new DeployActionUnitResponse()
.Ok(DeployActionUnitResponse.DeployActionResponseType.NotCompletedJob));
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
public override DeployActionUnitResponse ExecuteCheck(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
var cloneRepositoryFolderDependency = GetDependencyFromSameSource <CloneDomainGithubRepository>
(sourceActionExecution, currentExecutionDeployActions);
var pathParameter = DeployResponseParametersDefinitions.MicroServices.CloneGitRepository.Path;
var repositoryPath = cloneRepositoryFolderDependency.ResponseParameters[pathParameter] as string;
var sourceFolder = FileService.ConcatDirectoryAndFileOrFolder
(repositoryPath, DeployDefinitions.SourceFolderName);
var existsRepositoriesFolder = FileService.ExistsFolder(sourceFolder);
var docFolder = FileService.ConcatDirectoryAndFileOrFolder
(repositoryPath, DeployDefinitions.DocFolderName);
var existsDocFolder = FileService.ExistsFolder(docFolder);
var existsAll = existsRepositoriesFolder &&
existsDocFolder;
return(existsAll
? new DeployActionUnitResponse()
.Ok(GetResponseParameters(sourceFolder, docFolder), DeployActionUnitResponse.DeployActionResponseType.AlreadyCompletedJob)
: new DeployActionUnitResponse()
.Ok(DeployActionUnitResponse.DeployActionResponseType.NotCompletedJob));
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
public StateTransition(ActionTest shouldExecute, ActionExecution execute, T nextState, TransitionType transitionType)
{
ShouldExecuteAction = shouldExecute;
ExecuteAction = execute;
NextState = nextState;
TransitionType = transitionType;
}
public CleanDomainRepositoryFolder(
ActionExecution actionExecution,
IFileService fileService)
: base(actionExecution, ActionName, ActionDescription, DeployManager.Phases.EmptyProject, Positions.First, Positions.Fifth)
{
FileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
}
public virtual DeployActionUnitResponse ExecuteCheck(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
throw new NotImplementedException();
}
public override DeployActionUnitResponse ExecuteDeploy(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
var createrepositoryFolderStructureDependency = GetDependencyFromSameSource <CreateDomainRepositoryFolderStructure>
(sourceActionExecution, currentExecutionDeployActions);
var pathParameter = DeployResponseParametersDefinitions.MicroServices.CreateRepositoryFolderStructure.Source;
var sourcePath = createrepositoryFolderStructureDependency.ResponseParameters[pathParameter] as string;
var settingDotnet = GetSetting(projectState, Definitions.SettingsDefinitions.DotNetExePath);
DotnetService.Initialize(settingDotnet);
var projectName = $"{projectState.NameSpace}.{projectState.Name}.Domain";
var solutionFileName = GetSolutionFileName(projectName);
var solutionFilePath = FileService.ConcatDirectoryAndFileOrFolder(sourcePath, solutionFileName);
var existsSolution = FileService.ExistsFile(solutionFilePath);
if (!existsSolution)
{
DotnetService.CreateSolutionFile(sourcePath, solutionFileName);
}
return(new DeployActionUnitResponse()
.Ok(GetParameters(sourcePath, solutionFileName, solutionFilePath)));
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
public override DeployActionUnitResponse ExecuteDeploy(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
var cloneRepositoryFolderDependency = GetDependencyFromSameSource <CloneGitRepository>(sourceActionExecution, currentExecutionDeployActions);
var pathParameter = DeployResponseParametersDefinitions.MicroServices.CloneGitRepository.Path;
var repositoryPath = cloneRepositoryFolderDependency.ResponseParameters[pathParameter] as string;
var folderIsEmpty = FileService.FolderIsEmpty(repositoryPath);
if (!folderIsEmpty)
{
FileService.CleanFolder(repositoryPath);
}
return(new DeployActionUnitResponse()
.Ok(GetParameters(repositoryPath), DeployActionUnitResponse.DeployActionResponseType.AlreadyCompletedJob));
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
public CreateGithubRepository(
ActionExecution actionExecution,
IGithubClientService githubClientService)
: base(actionExecution, ActionName, ActionDescription, DeployManager.Phases.AvailableInfrastructure, Positions.First, Positions.First)
{
GithubClientService = githubClientService ?? throw new ArgumentNullException(nameof(githubClientService));
}
public override DeployActionUnitResponse ExecuteDeploy(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
var createProjectFolder = GetDependencyFromSameSource <CreateDomainProjectFolder>
(sourceActionExecution, currentExecutionDeployActions);
var pathParameter = DeployResponseParametersDefinitions.Project.CreateDomainProjectFolder.Path;
var projectPath = createProjectFolder.ResponseParameters[pathParameter] as string;
var settingDD = GetSetting(projectState, SettingsDefinitions.DDCliExePath);
var settingDomainTemplate = GetSetting(projectState, SettingsDefinitions.DDCliDomainProjectTemplatePath);
var projectFileName = $"{projectState.NameSpace}.{projectState.Name}.Domain.csproj";
var completeProjectPath = FileService.ConcatDirectoryAndFileOrFolder(projectPath, projectFileName);
DDService.Initialize(settingDD);
DDService.Template(projectPath, settingDomainTemplate, projectState.NameSpace, projectState.Name);
return(new DeployActionUnitResponse()
.Ok(GetParameters(projectPath, projectFileName, completeProjectPath), DeployActionUnitResponse.DeployActionResponseType.AlreadyCompletedJob));
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
private void OnPreSpell(ActionExecution combatAction)
{
var spellAction = combatAction as SpellAction;
if (spellAction.SkillExecution != null)
{
StopMove();
if (spellAction.SkillAbility is SkillAbility_1006)
{
return;
}
if (spellAction.SkillExecution.InputTarget != null)
{
transform.GetChild(0).LookAt(spellAction.SkillExecution.InputTarget.Position);
}
else if (spellAction.SkillExecution.InputPoint != null)
{
transform.GetChild(0).LookAt(spellAction.SkillExecution.InputPoint);
}
else
{
transform.GetChild(0).localEulerAngles = new Vector3(0, spellAction.SkillExecution.InputDirection, 0);
}
CombatEntity.Position = transform.position;
CombatEntity.Direction = transform.GetChild(0).localEulerAngles.y;
}
}
public override DeployActionUnitResponse ExecuteDeploy(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
var createDomainProject = GetDependencyFromSameSource <CreateDomainProject>
(sourceActionExecution, currentExecutionDeployActions);
var createDomainSolution = GetDependencyFromSameSource <CreateDomainSolutionFile>
(sourceActionExecution, currentExecutionDeployActions);
var domainSolutionFolderParameter = DeployResponseParametersDefinitions.Project.CreateDomainSolutionFile.Path;
var domainSolutionNameParameter = DeployResponseParametersDefinitions.Project.CreateDomainSolutionFile.SolutionFileName;
var domainSolutionFolder = createDomainSolution.ResponseParameters[domainSolutionFolderParameter] as string;
var domainSolutionName = createDomainSolution.ResponseParameters[domainSolutionNameParameter] as string;
var projectPathParameter = DeployResponseParametersDefinitions.Project.CreateDomainProject.ProjectFilePath;
var projectPath = createDomainProject.ResponseParameters[projectPathParameter] as string;
var relativePath = projectPath.Replace(domainSolutionFolder, "").Substring(1);
DotnetService.AddProjectToSolutionFile(domainSolutionFolder, domainSolutionName, relativePath);
return(new DeployActionUnitResponse()
.Ok(GetParameters(domainSolutionFolder, domainSolutionName, relativePath), DeployActionUnitResponse.DeployActionResponseType.AlreadyCompletedJob));
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
public override DeployActionUnitResponse ExecuteCheck(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
var githubSetting = GetCurrentGithubSetting(projectState);
GithubClientService.InitializeClientWithToken(githubSetting.OauthToken);
var completeName = GetRepositoryName(projectState, "domain");
var repository = GithubClientService.SearchRepository(completeName);
if (repository != null)
{
return(new DeployActionUnitResponse()
.Ok(repository.ToDictionary(), DeployActionUnitResponse.DeployActionResponseType.AlreadyCompletedJob));
}
return(new DeployActionUnitResponse()
.Ok(DeployActionUnitResponse.DeployActionResponseType.NotCompletedJob));
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
public CreateDomainGithubRepository(
ActionExecution actionExecution,
IGithubClientService githubClientService)
: base(actionExecution, ActionName, ActionDescription, DeployManager.Phases.EmptyProject)
{
GithubClientService = githubClientService ?? throw new ArgumentNullException(nameof(githubClientService));
}
private void OnPostSpell(ActionExecution combatAction)
{
var spellAction = combatAction as SpellAction;
if (spellAction.SkillExecution != null)
{
AnimationComponent.PlayFade(AnimationComponent.IdleAnimation);
}
}
public CreateSolutionFile(
ActionExecution actionExecution,
IDotnetService dotnetService,
IFileService fileService)
: base(actionExecution, ActionName, ActionDescription, DeployManager.Phases.AvailableInfrastructure, Positions.Second, Positions.First)
{
DotnetService = dotnetService ?? throw new ArgumentNullException(nameof(dotnetService));
FileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
}
public CheckOutMasterDomainRepository(
ActionExecution actionExecution,
IGitClientService gitClientService,
IFileService fileService)
: base(actionExecution, ActionName, ActionDescription, DeployManager.Phases.EmptyProject, Positions.First, Positions.Forth)
{
GitClientService = gitClientService ?? throw new ArgumentNullException(nameof(gitClientService));
FileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
}
public CreateDomainProject(
ActionExecution actionExecution,
IDDService dDService,
IFileService fileService)
: base(actionExecution, ActionName, ActionDescription, DeployManager.Phases.EmptyProject, Positions.Second, Positions.Third)
{
DDService = dDService ?? throw new ArgumentNullException(nameof(dDService));
FileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
}
public AddDomainProjectToDomainSolution(
ActionExecution actionExecution,
IDotnetService dotnetService,
IFileService fileService)
: base(actionExecution, ActionName, ActionDescription, DeployManager.Phases.EmptyProject, Positions.Second, Positions.Forth)
{
DotnetService = dotnetService ?? throw new ArgumentNullException(nameof(dotnetService));
FileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
}
public CloneGitRepository(
ActionExecution actionExecution,
IGitClientService gitClientService,
IFileService fileService)
: base(actionExecution, ActionName, ActionDescription, DeployManager.Phases.AvailableInfrastructure, Positions.First, Positions.Third)
{
GitClientService = gitClientService ?? throw new ArgumentNullException(nameof(gitClientService));
FileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
}
public void OnPreJumpTo(ActionExecution action)
{
var jumpToAction = action as JumpToAction;
var targetPoint = jumpToAction.Target.ModelObject.transform.position + jumpToAction.Target.ModelObject.transform.forward * 2;
jumpToAction.Creator.ModelObject.transform.DOMove(targetPoint, jumpToAction.Creator.JumpToTime / 1000f).SetEase(Ease.Linear);
var AnimationComponent = jumpToAction.Creator.ModelObject.GetComponent <CombatObjectData>().AnimationComponent;
AnimationComponent.Speed = 2f;
AnimationComponent.PlayFade(AnimationComponent.RunAnimation);
}
internal T GetDependencyFromSameSource <T>(ActionExecution sourceActionExecution, List <DeployActionUnit> currentExecutionDeployActions)
{
var sameSourceDeployActions = currentExecutionDeployActions
.Where(k => k.ActionExecution.Id == sourceActionExecution.Id && k.State == DeployState.Completed);
var dependency = sameSourceDeployActions
.OfType <T>();
if (dependency.Count() == 0)
{
throw new Exception($"Can't find any '{typeof(T).Name}' deploy action required before this action");
}
return(dependency.First());
}
public async void OnPostAttack(ActionExecution action)
{
transform.DOMove(SeatPoint, CombatEntity.JumpToTime / 1000f).SetEase(Ease.Linear);
var modelTrm = transform.GetChild(0);
modelTrm.forward = -modelTrm.forward;
AnimationComponent.Speed = 2f;
AnimationComponent.PlayFade(AnimationComponent.RunAnimation);
await TimeHelper.WaitAsync(CombatEntity.JumpToTime);
AnimationComponent.Speed = 1f;
AnimationComponent.PlayFade(AnimationComponent.IdleAnimation);
modelTrm.forward = -modelTrm.forward;
}
private void OnReceiveDamage(ActionExecution combatAction)
{
var damageAction = combatAction as DamageAction;
HealthBarImage.fillAmount = CombatEntity.CurrentHealth.Percent();
var damageText = GameObject.Instantiate(DamageText);
damageText.transform.SetParent(CanvasTrm);
damageText.transform.localPosition = Vector3.up * 120;
damageText.transform.localScale = Vector3.one;
damageText.transform.localEulerAngles = Vector3.zero;
damageText.text = $"-{damageAction.DamageValue.ToString()}";
damageText.GetComponent <DOTweenAnimation>().DORestart();
GameObject.Destroy(damageText.gameObject, 0.5f);
}
public override List <DeployActionUnit> GetDeployActionUnits(ActionExecution actionExecution)
{
return(new List <DeployActionUnit>()
{
new CreateDomainGithubRepository(actionExecution, GithubClientService),
new CreateRepositoriesFolder(actionExecution, FileService),
new CloneDomainGithubRepository(actionExecution, GitClientService, FileService),
new CheckOutMasterDomainRepository(actionExecution, GitClientService, FileService),
new CleanDomainRepositoryFolder(actionExecution, FileService),
new CreateDomainRepositoryFolderStructure(actionExecution, FileService),
new CreateDomainSolutionFile(actionExecution, DotnetService, FileService),
new CreateDomainProjectFolder(actionExecution, FileService),
new CreateDomainProject(actionExecution, DDService, FileService),
new AddDomainProjectToDomainSolution(actionExecution, DotnetService, FileService)
});
}
public override DeployActionUnitResponse ExecuteCheck(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
return(new DeployActionUnitResponse()
.Ok(DeployActionUnitResponse.DeployActionResponseType.NotCompletedJob));
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
private void OnReceiveCure(ActionExecution combatAction)
{
var action = combatAction as CureAction;
CombatObjectData.HealthBarImage.fillAmount = CombatEntity.CurrentHealth.Percent();
var cureText = GameObject.Instantiate(CombatObjectData.CureText);
cureText.transform.SetParent(CombatObjectData.CanvasTrm);
cureText.transform.localPosition = Vector3.up * 120;
cureText.transform.localScale = Vector3.one;
cureText.transform.localEulerAngles = Vector3.zero;
cureText.text = $"+{action.CureValue.ToString()}";
cureText.GetComponent <DOTweenAnimation>().DORestart();
GameObject.Destroy(cureText.gameObject, 0.5f);
}
public override DeployActionUnitResponse ExecuteCheck(
ProjectState projectState,
ActionExecution sourceActionExecution,
List <DeployActionUnit> currentExecutionDeployActions)
{
try
{
var domainName = sourceActionExecution.InputParameters[ActionsParametersDefinitions.AddDomainInMicroservice.DomainName] as string;
var microserviceName = sourceActionExecution.InputParameters[ActionsParametersDefinitions.AddDomainInMicroservice.MicroserviceName] as string;
var domain = projectState.Domains.First(k => k.Name == domainName);
//var microservice = projectState.Microservices.First(k => k.Name == microserviceName);
//var solutionDependency = GetDependency<CreateSolutionFile>
// (sourceActionExecution, currentExecutionDeployActions,
// k =>
// k.ActionExecution.OutputParameters.ContainsKey(ActionsParametersDefinitions.AddMicroService.Name)
// && k.ActionExecution.OutputParameters[ActionsParametersDefinitions.AddMicroService.Name] as string == microserviceName);
//var solutionFolder = solutionDependency.ResponseParameters[DeployResponseParametersDefinitions.MicroServices.CreateSolutionFile.Path] as string;
//var projectFileName = GetDomainProjectName(projectState, domainName);
//var projectFolder = FileService.ConcatDirectoryAndFileOrFolder(solutionFolder, projectFileName);
//var existsFolder = FileService.ExistsFolder(projectFolder);
//if (!existsFolder)
//{
// return new DeployActionUnitResponse()
// .Ok(DeployActionUnitResponse.DeployActionResponseType.NotCompletedJob);
//}
//var currentBranch = GitClientService.GetCurrentBranchRepository(repositoryPath);
//if (currentBranch != BranchDefinitions.Master)
//{
// return new DeployActionUnitResponse()
// .Ok(DeployActionUnitResponse.DeployActionResponseType.NotCompletedJob);
//}
//return new DeployActionUnitResponse()
// .Ok(GetParameters(currentBranch), DeployActionUnitResponse.DeployActionResponseType.AlreadyCompletedJob);
return(null);
}
catch (Exception ex)
{
return(new DeployActionUnitResponse()
.Error(ex));
}
}
public BTCheckKeyOrTouch(ActionExecution ae)
{
_ae = ae;
}
