public virtual async Task RefreshZipOptions(ApplicationManagerClient appMgr, EnterpriseManagerClient entMgr, string entLookup)
{
log.LogInformation($"Refreshing Zip Options for {entLookup}");
State.ZipAppOptions = new List <ZipAppOption>();
var entRes = await entMgr.GetEnterprise(entLookup);
if (entRes.Status)
{
// var listRes = await appMgr.Get<ListFilesResponse>($"dfs/list/{entRes.Model.ID}/app-uploads/application/zip");
log.LogInformation($"Listing files for Zip Options");
var listRes = await appMgr.ListFiles(entRes.Model.ID, $"app-uploads/application/zip");
if (listRes.Status)
{
State.ZipAppOptions = listRes.Files.Select(file =>
{
return(new ZipAppOption()
{
DisplayName = file,
File = file
});
}).ToList();
}
}
State.ZipLoading = false;
}
public override async Task <AbstractRobot[]> PripojeniRoboti()
{
if (EnterpriseManagerClient == null)
{
Connect();
}
var identifikatoryRobotuPripojenychNaServer = EnterpriseManagerClient.RefreshConnectedRobots();
await Task.Delay(10);
LynxModel[] vysledek = new LynxModel[identifikatoryRobotuPripojenychNaServer.Where(x => x != null).Count()];
int indexPole = 0;
foreach (string identifikator in identifikatoryRobotuPripojenychNaServer)
{
DnsInfo robotDnsInfo = GetHostNameAndIPAdress.DnsInfoFromHostname($"AGV_{identifikator}");
LynxModel pripojenyRobot = new LynxModel
{
Hostname = identifikator,
IpAdress = robotDnsInfo.IP.ToString()
};
vysledek[indexPole] = pripojenyRobot;
indexPole++;
}
return(vysledek);
}
public override bool Connect()
{
try
{
if (EnterpriseManagerClient == null)
{
EnterpriseManagerSetup();
}
if (ZarizeniJeDlePinguOnline)
{
EnterpriseManagerClient?.Connect();
}
bool status = false;
status = EnterpriseManagerClient.Connected;
if (status)
{
Status = Stav.Online;
}
return(status);
}
catch (Exception exception)
{
var zarizeniArgs = new ZarizeniArgs(Status, Ping, $"!CHYBA!", exception);
OnStatusChanged(zarizeniArgs);
return(false);
}
}
public SetActiveDataFlow(EnterpriseManagerClient entMgr, ApplicationManagerClient appMgr, ApplicationDeveloperClient appDev)
{
this.appDev = appDev;
this.entMgr = entMgr;
this.appMgr = appMgr;
}
public AddPhoto(AmblOnGraph amblGraph, EnterpriseManagerClient entMgr, ApplicationManagerClient appMgr)
{
this.amblGraph = amblGraph;
this.appMgr = appMgr;
this.entMgr = entMgr;
}
public virtual async Task Refresh(EnterpriseManagerClient entMgr, ApplicationManagerClient appMgr, ApplicationDeveloperClient appDev, string entApiKey, string host)
{
await LoadEnvironment(entMgr, entApiKey);
await LoadDataFlows(appMgr, appDev, entApiKey);
await LoadModulePackSetup(entMgr, appMgr, entApiKey, host);
}
public Refresh(EnterpriseManagerClient entMgr, ApplicationManagerClient appMgr, ApplicationDeveloperClient appDev)
{
this.appDev = appDev;
this.appMgr = appMgr;
this.entMgr = entMgr;
}
public virtual async Task AreAzureEnvSettingsValid(EnterpriseManagerClient entMgr)
{
var config = State.EnvSettings.JSONConvert <AzureInfrastructureConfig>();
var valid = await entMgr.AreEnvironmentSettingsValid(config, "check-app");
State.AzureInfrastructureValid = valid.Status;
}
public ForgeInfrastructureStateHarness(HttpRequest req, ILogger logger, ForgeInfrastructureState state)
: base(req, logger, state)
{
devOpsArch = req.ResolveClient <DevOpsArchitectClient>(logger);
entMgr = req.ResolveClient <EnterpriseManagerClient>(logger);
secMgr = req.ResolveClient <SecurityManagerClient>(logger);
}
public virtual async Task LoadRegistrationHosts(EnterpriseManagerClient entMgr, string entApiKey)
{
if (State.HostOptions.IsNullOrEmpty())
{
var regHosts = await entMgr.ListRegistrationHosts(entApiKey);
State.HostOptions = regHosts.Model;
}
}
public CompletePayment(EnterpriseManagerClient entMgr, SecurityManagerClient secMgr, IdentityManagerClient idMgr)
{
billingEntApiKey = Environment.GetEnvironmentVariable("LCU-BILLING-ENTERPRISE-API-KEY");
this.entMgr = entMgr;
this.idMgr = idMgr;
this.secMgr = secMgr;
}
public Refresh(EnterpriseArchitectClient entArch, EnterpriseManagerClient entMgr, SecurityManagerClient secMgr)
{
billingEntApiKey = Environment.GetEnvironmentVariable("LCU-BILLING-ENTERPRISE-API-KEY");
this.entArch = entArch;
this.entMgr = entMgr;
this.secMgr = secMgr;
}
public Refresh(ApplicationManagerClient appMgr, EnterpriseManagerClient entMgr, IdentityManagerClient idMgr,
SecurityManagerClient secMgr)
{
this.appMgr = appMgr;
this.entMgr = entMgr;
this.idMgr = idMgr;
this.secMgr = secMgr;
}
public NapkinIDESetupStateHarness(HttpRequest req, ILogger logger, NapkinIDESetupState state)
: base(req, logger, state)
{
devOpsArch = req.ResolveClient <DevOpsArchitectClient>(logger);
entArch = req.ResolveClient <EnterpriseArchitectClient>(logger);
entMgr = req.ResolveClient <EnterpriseManagerClient>(logger);
idMgr = req.ResolveClient <IdentityManagerClient>(logger);
}
public Refresh(EnterpriseArchitectClient entArch, EnterpriseManagerClient entMgr, IdentityManagerClient idMgr,
SecurityManagerClient secMgr)
{
this.entArch = entArch;
this.entMgr = entMgr;
this.idMgr = idMgr;
this.secMgr = secMgr;
}
public BootOrganizationOrchestration(ApplicationDeveloperClient appDev, DevOpsArchitectClient devOpsArch, EnterpriseArchitectClient entArch,
EnterpriseManagerClient entMgr)
{
this.appDev = appDev;
this.devOpsArch = devOpsArch;
this.entArch = entArch;
this.entMgr = entMgr;
}
public virtual async Task CompletePayment(EnterpriseManagerClient entMgr, SecurityManagerClient secMgr, IdentityManagerClient idMgr, string entApiKey,
string username, string methodId, string customerName, string plan, int trialPeriodDays)
{
State.CustomerName = customerName;
State.PaymentMethodID = methodId;
// var completeResp = await entMgr.Post<CompleteStripeSubscriptionRequest, CompleteStripeSubscriptionResponse>($"billing/{entApiKey}/stripe/subscription",
var completeResp = await entMgr.CompleteStripeSubscription(entApiKey,
new CompleteStripeSubscriptionRequest()
{
CustomerName = State.CustomerName,
PaymentMethodID = methodId,
Plan = plan,
TrialPeriodDays = trialPeriodDays,
Username = username
});
State.PaymentStatus = completeResp.Status;
if (State.PaymentStatus)
{
State.PurchasedPlanLookup = plan;
var resp = await secMgr.SetIdentityThirdPartyData(entApiKey, username, new Dictionary <string, string>()
{
{ "LCU-USER-BILLING.TermsOfService", DateTimeOffset.UtcNow.ToString() },
{ "LCU-USER-BILLING.EnterpriseAgreement", DateTimeOffset.UtcNow.ToString() }
});
var planOption = this.State.Plans.First(p => p.Lookup == plan);
var licenseType = planOption.Metadata["LicenseType"].ToString();
var token = planOption.JSONConvert <LicenseAccessToken>();
token.EnterpriseAPIKey = entApiKey;
token.Lookup = licenseType;
token.AccessStartDate = DateTime.Now;
token.TrialPeriodDays = trialPeriodDays;
token.Username = username;
var setLicenseAccessResp = await idMgr.IssueLicenseAccess(token, entApiKey);
State.PaymentStatus = setLicenseAccessResp.Status;
State.SuccessRedirect = licenseType == "lcu" ? "/workspace/new" : "https://forecast.fathym-it.com/";
}
}
protected override void PingniNaZarizeni()
{
base.PingniNaZarizeni();
if (EnterpriseManagerClient != null)
{
if (EnterpriseManagerClient.Connected == false)
{
EnterpriseManagerClient.Connect();
}
}
}
public virtual async Task <Status> CanFinalize(EnterpriseManagerClient entMgr, string parentEntApiKey, string username)
{
var status = Status.GeneralError;
if (!State.NewEnterpriseAPIKey.IsNullOrEmpty() && !State.EnvironmentLookup.IsNullOrEmpty())
{
var canFinalize = await entMgr.EnsureInfraBuiltAndReleased(State.NewEnterpriseAPIKey, username, State.EnvironmentLookup, parentEntApiKey);
status = canFinalize.Status;
}
return(status);
}
public DataFlowManagerStateHarness(HttpRequest req, ILogger logger, DataFlowManagerState state)
: base(req, logger, state)
{
appMgr = req.ResolveClient <ApplicationManagerClient>(logger);
devOpsArch = req.ResolveClient <DevOpsArchitectClient>(logger);
entArch = req.ResolveClient <EnterpriseArchitectClient>(logger);
entMgr = req.ResolveClient <EnterpriseManagerClient>(logger);
idMgr = req.ResolveClient <IdentityManagerClient>(logger);
}
private void EnterpriseManagerSetup()
{
PingniNaZarizeni();
EnterpriseManagerClient = new EnterpriseManagerClient(Hostname, IPAddress.Parse(IpAdress), Port)
{
ManageJobs = ArclBase.JobManagement.Full,
QueuedResponses = ArclBase.ResponseFlag.All
};
EnterpriseManagerClient.Responses.MaxLength = 500;
EnterpriseManagerClient.Password = "******";
EnterpriseManagerClient.ResponseTimeout = 2000;
EnterpriseManagerClient.AutoReconnect = true;
EnterpriseManagerClient.ConnectedRobotsComplete += EnterpriseManagerClient_ConnectedRobotsComplete;
EnterpriseManagerClient.NewJobQueued += EnterpriseManagerClient_NewJobQueued;
}
public virtual async Task LoadBillingPlans(EnterpriseManagerClient entMgr, string entApiKey, string licenseType)
{
var plansResp = await entMgr.ListBillingPlanOptions(entApiKey, licenseType);
State.Plans = plansResp.Model ?? new List <BillingPlanOption>();
State.FeaturedPlanGroup = State.Plans.FirstOrDefault(plan =>
{
return(plan.Metadata.ContainsKey("Featured") && plan.Metadata["Featured"].ToObject <bool>());
})?.PlanGroup;
State.PopularPlanGroup = State.Plans.FirstOrDefault(plan =>
{
return(plan.Metadata.ContainsKey("Popular") && plan.Metadata["Popular"].ToObject <bool>());
})?.PlanGroup;
}
public override bool Disconnect()
{
try
{
EnterpriseManagerClient?.Disconnect();
bool status = false;
status = (bool)EnterpriseManagerClient?.Connected ? status : false;
Status = Stav.Offline;
return(true);
}
catch (Exception exception)
{
Status = Stav.InError;
var zarizeniArgs = new ZarizeniArgs(Status, Ping, $"!CHYBA!", exception);
OnStatusChanged(zarizeniArgs);
return(false);
}
}
public virtual async Task Refresh(EnterpriseManagerClient entMgr, SecurityManagerClient secMgr, string entApiKey, string username, string licenseType)
{
ResetStateCheck();
await LoadBillingPlans(entMgr, entApiKey, licenseType);
var ltName = licenseType == "lcu" ? "Fathym Framework" : licenseType == "forecast" ? "Fathym Forecast" : "";
State.LicenseType = new LicenseTypeDetails()
{
Lookup = licenseType,
Name = ltName
};
SetUsername(username);
await DetermineRequiredOptIns(secMgr, entApiKey, username);
}
public virtual async Task Refresh(ApplicationManagerClient appMgr, EnterpriseManagerClient entMgr, IdentityManagerClient idMgr,
SecurityManagerClient secMgr, string entLookup, string host)
{
log.LogInformation($"Refreshing data apps management state for {entLookup} at {State.ActiveHost}");
// if (State.ActiveHost.IsNullOrEmpty())
SetActiveHost(host);
await LoadApplications(appMgr, entLookup);
await Task.WhenAll(
LoadAccessRightOptions(idMgr, entLookup),
LoadDAFAppOptions(appMgr, entLookup),
LoadGlobalAppSettings(secMgr, entLookup),
RefreshZipOptions(appMgr, entMgr, entLookup)
);
await LoadSupportedDAFAppTypes();
}
public virtual async Task <Status> SecureHost(EnterpriseManagerClient entMgr)
{
var root = State.HostOptions.FirstOrDefault();
var host = $"{State.OrganizationLookup}.{root}";
try
{
var hostResp = await entMgr.ResolveHost(host, false);
if (hostResp.Status == Status.NotLocated)
{
State.Host = host;
}
return(hostResp.Status);
}
catch (Exception ex)
{
return(Status.NotLocated);
}
}
public virtual async Task SetOrganizationDetails(EnterpriseManagerClient entMgr, string name, string description, string lookup, bool accepted)
{
State.OrganizationName = name;
State.OrganizationDescription = description;
State.OrganizationLookup = lookup;
State.AzureLocationOptions = null;
State.AzureInfrastructureValid = null;
var secured = await SecureHost(entMgr);
if (secured == Status.NotLocated)
{
State.TermsAccepted = accepted;
if (!name.IsNullOrEmpty())
{
SetNapkinIDESetupStep(NapkinIDESetupStepTypes.AzureSetup);
}
else
{
SetNapkinIDESetupStep(NapkinIDESetupStepTypes.OrgDetails);
}
State.Status = null;
}
else
{
State.Status = new Status()
{
Code = (int)UserManagementErrorCodes.HostAlreadyExists,
Message = "An enterprise with that lookup already exists."
}
};
}
public virtual async Task UploadZips(ApplicationManagerClient appMgr, EnterpriseManagerClient entMgr, string entLookup,
List <ZipAppOption> zipApps)
{
log.LogInformation($"Uploading zip application options for {entLookup}");
var regex = new Regex("^data:(?<type>.*);base64,(?<data>.*)$");
var stati = new List <Status>();
await zipApps.Each(async zipApp =>
{
var match = regex.Match(zipApp.Data);
var dataType = match.Groups["type"].Value;
var base64Data = match.Groups["data"].Value;
var data = Convert.FromBase64String(base64Data);
var entRes = await entMgr.GetEnterprise(entLookup);
if (entRes.Status)
{
log.LogInformation($"Saving zip application option file for {entLookup}");
var saveRes = await appMgr.SaveFile(data, entRes.Model.ID, "", zipApp.File, null, $"app-uploads/{dataType}");
stati.Add(saveRes.Status);
}
else
{
stati.Add(entRes.Status);
}
});
await RefreshZipOptions(appMgr, entMgr, entLookup);
}
public ResetStateCheck(EnterpriseManagerClient entMgr, SecurityManagerClient secMgr)
{
this.entMgr = entMgr;
this.secMgr = secMgr;
}
public ToggleCreationModules(EnterpriseManagerClient entMgr, ApplicationManagerClient appMgr)
{
this.appMgr = appMgr;
this.entMgr = entMgr;
}
