private async Task LoadInfoService(int idEC)
{
try
{
var responseString = await(Data.URL + "Services/GetServiceByECenterId/" + idEC).WithHeader("Authorization", Data.Token).GetStringAsync();
servicesSuccsess = JsonConvert.DeserializeObject <ServicesResponse>(responseString);
var comboServiceSource = new Dictionary <int, string>();
foreach (var x in servicesSuccsess.data)
{
comboServiceSource.Add(x.Id, x.Name);
}
ServiceComboBox.DisplayMember = "Value";
ServiceComboBox.ValueMember = "Key";
if (comboServiceSource.Count > 0)
{
ServiceComboBox.DataSource = new BindingSource(comboServiceSource, null);
await LoadServiceField(comboServiceSource.Keys.FirstOrDefault());
}
else
{
ServiceComboBox.DataSource = null;
await LoadServiceField(-1);
}
}
catch { }
}
public ServicesResponse GetAdminServices(ServicesRequest request)
{
var response = new ServicesResponse {
ResponseStatus = ResponseStatus.Success
};
var settingsProvider = new SettingsProvider();
try
{
if (request.ActionType == ActionType.Select)
{
response.Services = settingsProvider.GetServices(request);
}
else
{
response.ResponseStatus = ResponseStatus.Failure;
response.ResponseDescription = "Not update action";
}
}
catch (Exception ex)
{
response.ResponseStatus = ResponseStatus.Failure;
response.ResponseDescription = ex.Message;
}
return(response);
}
public static async Task <ServicesResponse <T2> > PostRequestAsync <T1, T2>(Adapter adapter, T1 t, string endpoint)
{
var servicesResponse = new ServicesResponse <T2>();
try
{
HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(t));
HttpResponseMessage response = await Client.PostAsync(new Uri(adapter.uri, endpoint), httpContent);
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsStringAsync();
servicesResponse.isSuccess = true;
servicesResponse.resultObject = JsonConvert.DeserializeObject <T2>(result);
}
else
{
servicesResponse.errorCode = (int)response.StatusCode;
var errorMessage = await response.Content.ReadAsStringAsync();
servicesResponse.errorMessage = errorMessage;
}
}
catch (Exception ex)
{
servicesResponse.errorCode = 500;
servicesResponse.errorMessage = ex.Message;
}
return(servicesResponse);
}
public static async Task <ServicesResponse> GetDatacenters(Adapter adapter)
{
ServicesResponse servicesResponse = await ApiService.GetRequest(adapter, typeof(DataCenters), "ovirt-engine/api/datacenters");
servicesResponse.resultObject = (DataCenters)servicesResponse.resultObject;
return(servicesResponse);
}
public async Task <IActionResult> Remove(Vm vM)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (vM?.Adapter == null)
{
return(BadRequest());
}
Adapter adapter = await _context.Adapters.Where(x => x.IsOK)
.Include(c => c.Credentials)
.Include(p => p.Provider)
.Where(a => a.Id == vM.Adapter.Id)
.SingleOrDefaultAsync();
ServicesResponse shutdownVmResponse = new ServicesResponse();
switch (adapter.Provider.Name.ToLower())
{
case "ovirt":
shutdownVmResponse = await VmService.RemoveVm(adapter, vM.Id);
if (!shutdownVmResponse.isSuccess)
{
return(BadRequest(shutdownVmResponse.errorMessage));
}
break;
}
return(Ok(shutdownVmResponse));
}
public async Task <IActionResult> RequestVm(Vm newVm)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.ToString()));
}
if (newVm?.Cluster?.Datacenter?.Adapter == null)
{
return(BadRequest("Неверно заполнены поля"));
}
#region CheckResponsibles
// Проверка на корректность задания ответственных: администратора, менеджера и владельца
var responsibles = new List <User>()
{
newVm.Admin, newVm.Manager, newVm.Owner
};
responsibles = responsibles.GroupBy(x => x.Sam).Select(x => x.FirstOrDefault()).ToList();
List <User> users = _authService.GetUsersList(responsibles);
if (responsibles.Count != users.Count)
{
return(BadRequest("Неверно заполнены поля ответственных за ВМ. Пожалуйста, выберите тех, кто есть в списке"));
}
#endregion
Adapter adapter = await _context.Adapters.Where(x => x.IsOK).Include(c => c.Credentials)
.Include(p => p.Provider)
.Where(a => a.Id == newVm.Cluster.Datacenter.Adapter.Id)
.SingleOrDefaultAsync();
var auditDays = (await _context.Audits.SingleOrDefaultAsync(x => x.AdapterId == adapter.Id && x.DatacenterId == newVm.Cluster.Datacenter.Id && x.ClusterId == newVm.Cluster.Id))?.AuditDays;
if (auditDays != null)
{
newVm.AuditDate = DateTime.Now.ToShortDateString();
newVm.Deadline = DateTime.Now.AddDays((double)auditDays).ToShortDateString();
}
var user = User.Claims.SingleOrDefault(x => x.Type == ClaimTypes.Name).Value;
switch (adapter.Provider.Id)
{
case (int)ProviderType.Ovirt:
ServicesResponse newVmResponse = await VmService.RequestVm(newVm, adapter, newVm.Network.Id, newVm.HddSize, newVm.Cluster.Datacenter.Id);
if (!newVmResponse.isSuccess)
{
return(StatusCode(newVmResponse.errorCode, newVmResponse.errorMessage));
}
break;
case (int)ProviderType.VMware:
var task = await SendVmRequest(adapter, newVm, user);
TrackBackendTask(adapter, task);
break;
}
_mailer.NotifyVmRequested(users, newVm);
return(CreatedAtAction("RequestVm", newVm));
}
public static async Task <ServicesResponse> GetRequest(Adapter adapter, Type type, string endpoint)
{
ServicesResponse servicesResponse = new ServicesResponse();
SetHeaders(adapter);
HttpResponseMessage response = await Client.GetAsync(new Uri(adapter.uri, endpoint));
if (response.IsSuccessStatusCode)
{
string responseBody = await response.Content.ReadAsStringAsync();
servicesResponse.resultObject = XmlDeserialize(responseBody, type);
servicesResponse.isSuccess = true;
}
else
{
servicesResponse.errorCode = (int)response.StatusCode;
var errorMessage = await response.Content.ReadAsStringAsync();
try
{
var fault = XmlDeserialize <Fault>(errorMessage);
servicesResponse.errorMessage = fault.Detail;
}
catch (Exception)
{
servicesResponse.errorMessage = errorMessage;
}
}
return(servicesResponse);
}
public static async Task <ServicesResponse> PutRequest <objIn, objOut>(Adapter adapter, object objectIn, string endpoint)
{
ServicesResponse servicesResponse = new ServicesResponse();
SetHeaders(adapter);
string xmlString = XmlSerialize(objectIn, typeof(objIn));
HttpContent httpContent = new StringContent(xmlString, Encoding.UTF8, "application/xml");
HttpResponseMessage response = await Client.PutAsync(new Uri(adapter.uri, endpoint), httpContent);
if (response.IsSuccessStatusCode)
{
string responseBody = await response.Content.ReadAsStringAsync();
servicesResponse.resultObject = XmlDeserialize(responseBody, typeof(objOut));
servicesResponse.isSuccess = true;
}
else
{
servicesResponse.errorCode = (int)response.StatusCode;
var errorMessage = await response.Content.ReadAsStringAsync();
try
{
var fault = XmlDeserialize <Fault>(errorMessage);
servicesResponse.errorMessage = fault.Detail;
}
catch (Exception)
{
servicesResponse.errorMessage = errorMessage;
}
}
return(servicesResponse);
}
private void btnExecute_Click(object sender, EventArgs e)
{
try
{
ConsignmentResponse consignmentResponse;
FzShipMate fzShipMate = new FzShipMate();
switch (_fzShipMateAction)
{
case FzShipMateAction.Login:
LoginResponse loginResponse = fzShipMate.Login(new LoginRequest(fzShipMate.UserName, fzShipMate.Password));
this.txtResponse.Text = loginResponse.ToString();
break;
case FzShipMateAction.Services:
ServicesResponse servicesResponse = fzShipMate.GetServices();
this.txtResponse.Text = servicesResponse.ToString();
break;
case FzShipMateAction.CreateConsignment:
List <Parcel> list = new List <Parcel>();
Parcel parcel = new Parcel(this.txt_reference.Text, int.Parse(this.txt_weight.Text), int.Parse(this.txt_width.Text), int.Parse(this.txt_length.Text), int.Parse(this.txt_depth.Text));
list.Add(parcel);
consignmentResponse = fzShipMate.CreateConsignment(new ConsignmentRequest(int.Parse(this.txt_ServiceID.Text), int.Parse(this.txt_RemittanceID.Text), this.txt_consignment_reference.Text, this.txt_Token.Text, this.txt_service_key.Text, new ToAddressRequest(this.txt_name.Text, this.txt_line_1.Text, this.txt_city.Text, this.txt_postcode.Text, this.txt_country.Text), list));
this.txtResponse.Text = consignmentResponse.ToString();
break;
case FzShipMateAction.TrackingByConsignment:
TrackingConsignmentResponse trackingConsignmentResponse = fzShipMate.TrackingByConsignment(this.txt_consignment_reference.Text);
this.txtResponse.Text = trackingConsignmentResponse.ToString();
break;
case FzShipMateAction.TrackingByParcels:
TrackingByParcelsResponse trackingByParcelsResponse = fzShipMate.TrackingByParcels(this.txt_Tracking_reference.Text);
this.txtResponse.Text = trackingByParcelsResponse.ToString();
break;
case FzShipMateAction.CancelConsignment:
CancelConsignmentResponse cancelConsignmentResponse = fzShipMate.CancelConsignments(this.txt_consignment_reference.Text);
this.txtResponse.Text = cancelConsignmentResponse.ToString();
break;
case FzShipMateAction.Label:
consignmentResponse = fzShipMate.GetLabel(this.txt_Tracking_reference.Text);
this.txtResponse.Text = consignmentResponse.ToString();
break;
case FzShipMateAction.PrintLabel:
consignmentResponse = fzShipMate.PrintLabel(this.txt_Tracking_reference.Text);
this.txtResponse.Text = consignmentResponse.ToString();
break;
}
}
catch (Exception ex)
{
this.txtResponse.Text = "An error happened: " + ex.Message;
}
}
public static async Task <ServicesResponse> ChangeState(Adapter adapter, string vmId, string shutOrStart)
{
Action action = new Action();
ServicesResponse servicesResponse = await ApiService.PostRequest <Action>(adapter, action, $"ovirt-engine/api/vms/{vmId}/{shutOrStart}");
action = (Action)servicesResponse.resultObject;
servicesResponse.resultObject = action.Status;
return(servicesResponse);
}
public static ServicesResponse <TResponse> CreateServicesErrorResponse <TResponse>(string exceptionMessage = ExceptionMessageHelper.UnexpectedSystemError, ErrorTypeEnum errorType = ErrorTypeEnum.GeneralExeption)
{
var response = new ServicesResponse <TResponse>();
response.IsSuccess = false;
response.ErrorType = errorType;
response.ResponseMessage = exceptionMessage;
return(response);
}
public static async Task <ServicesResponse> RemoveVm(Adapter adapter, string vmId)
{
ServicesResponse servicesResponse = await ApiService.DeleteRequest(adapter, typeof(Action), $"ovirt-engine/api/vms/{vmId}");
Action action = (Action)servicesResponse.resultObject;
servicesResponse.resultObject = action.Status;
return(servicesResponse);
}
public static async Task <ServicesResponse> GetFullVms(Adapter adapter)
{
var servicesResponse = new ServicesResponse();
ServicesResponse vmsResponse = await GetVMs(adapter);
if (!vmsResponse.isSuccess)
{
return(servicesResponse);
}
List <Vm> ovirtVms = ((Vms)vmsResponse.resultObject).Vm;
ServicesResponse diskResponse = await DiskService.GetDisks(adapter);
if (!vmsResponse.isSuccess)
{
return(servicesResponse);
}
Shared.Ovirt.Disk.Disks ovirtDisks = (Shared.Ovirt.Disk.Disks)diskResponse.resultObject;
foreach (Vm ovirtVm in ovirtVms)
{
ServicesResponse ovirtVmDiskAttachmentResponse = await ApiService.GetRequest(adapter,
typeof(Shared.Ovirt.Disk.DiskAttachments),
ovirtVm.Link.SingleOrDefault(l => l.Rel == "diskattachments")?.Href);
if (!ovirtVmDiskAttachmentResponse.isSuccess)
{
break;
}
ovirtVm.DiskAttachments = (Shared.Ovirt.Disk.DiskAttachments)ovirtVmDiskAttachmentResponse.resultObject;
ovirtVm.DiskAttachments.DiskAttachment.ForEach(x => x.Disk = ovirtDisks.Disk.SingleOrDefault(y => y.Id == x.Disk.Id));
}
List <Shared.Ovirt.Datacenter.DataCenter> datacenters = ((DataCenters)(await DatacenterService.GetDatacenters(adapter)).resultObject).DataCenter;
List <Shared.Ovirt.Cluster> clusters = ((Clusters)(await ClusterService.GetClusters(adapter)).resultObject).Cluster;
List <Shared.Common.Vm> commonVMs = ovirtVms.ConvertAll(x => (Shared.Common.Vm)x);
foreach (var vm in commonVMs)
{
vm.Adapter = adapter;
vm.AdapterId = adapter.Id;
vm.Cluster = clusters.SingleOrDefault(x => x.Id == vm.Cluster.Id);
vm.ClusterId = vm.Cluster.Id;
vm.Cluster.Datacenter = datacenters.SingleOrDefault(x => x.Id == vm.Cluster.Datacenter.Id);
vm.DatacenterId = vm.Cluster.Datacenter.Id;
vm.ClusterName = vm.Cluster.Name;
vm.DatacenterName = vm.Cluster.Datacenter.Name;
}
servicesResponse.isSuccess = true;
servicesResponse.resultObject = commonVMs;
return(servicesResponse);
}
public async Task <IActionResult> Update(UpdateVenderDTO DTO)
{
ServicesResponse <VanderListDTO> response = await _VanderService.Update(DTO);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok());
}
public async Task <IActionResult> Delete(int id)
{
ServicesResponse <List <VanderListDTO> > response = await _VanderService.Delete(id);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok());
}
public void Refresh()
{
if (string.IsNullOrEmpty(this.AccessToken))
{
this.CallRegister(this.clientId, this.clientSecret,
(resp) =>
{
System.Diagnostics.Debug.WriteLine("Success: " + resp.AccessToken);
this.AccessToken = resp.AccessToken;
if (this.AccessTokenReceived != null)
{
this.AccessTokenReceived(this.AccessToken);
}
this.CallGetServices(
(res) =>
{
this.Services = res;
this.RefreshServices = false;
if (this.ServicesReceived != null)
{
this.ServicesReceived(res);
}
},
(err) =>
{
System.Diagnostics.Debug.WriteLine("Failure: " + err);
});
},
(err) =>
{
System.Diagnostics.Debug.WriteLine("Failure: " + err);
});
}
else if (this.RefreshServices || this.Services == null)
{
this.CallGetServices(
(res) =>
{
this.Services = res;
this.RefreshServices = false;
if (this.ServicesReceived != null)
{
this.ServicesReceived(res);
}
},
(err) =>
{
System.Diagnostics.Debug.WriteLine("Failure: " + err);
});
}
}
public async IAsyncEnumerable <Cluster> Get(Datacenter datacenter)
{
if (datacenter?.Adapter == null)
{
yield return(null);
yield break;
}
List <Cluster> clusters = new List <Cluster>();
Adapter adapter = await _context.Adapters
.Where(x => x.IsOK)
.Include(x => x.Credentials)
.Include(x => x.Provider)
.SingleOrDefaultAsync(y => y.Id == datacenter.Adapter.Id);
if (adapter?.Provider == null)
{
yield return(null);
yield break;
}
switch (adapter.Provider.ProviderType)
{
case ProviderType.Ovirt:
ServicesResponse servicesResponse = await ClusterService.GetClusters(adapter);
if (servicesResponse.isSuccess)
{
OvirtClusters ovirtClusters = (OvirtClusters)servicesResponse.resultObject;
foreach (var cluster in ovirtClusters.Cluster)
{
if (cluster.DataCenter.Id == datacenter.Id)
{
yield return(cluster);
}
}
}
break;
case ProviderType.VMware:
var response = await EasyAdmin.Services.VMware.ClusterService.GetClustersListAsync(adapter, datacenter);
if (response.isSuccess)
{
foreach (var cluster in response.resultObject)
{
yield return(cluster);
}
}
break;
}
}
/// <summary>Returns a list of services the particular user has set up through Ping.fm.</summary>
public ServicesResponse GetServices()
{
string url = "http://api.ping.fm/v1/user.services";
string postdata = "api_key={0}&user_app_key={1}";
postdata = string.Format(postdata, api_key, user_application_key);
string response = GetWebResponse(url, postdata);
XmlReader xr = XmlReader.Create(new System.IO.StringReader(response));
ServicesResponse r = (ServicesResponse)DeserializeObject(xr, typeof(ServicesResponse));
xr.Close();
mLastResponse = r;
return(r);
}
public static async Task <ServicesResponse <OvirtDisk.DiskAttachments> > GetDiskAttachments(Adapter adapter, Shared.Common.Vm vm)
{
var servicesResponse = new ServicesResponse <OvirtDisk.DiskAttachments>();
if (adapter?.Credentials == null)
{
servicesResponse.errorCode = 500;
servicesResponse.errorMessage = "Adapter or credentials is null";
return(servicesResponse);
}
servicesResponse = await ApiService.GetRequest2 <OvirtDisk.DiskAttachments>(adapter, $"ovirt-engine/api/vms/{vm.Id}/diskattachments");
return(servicesResponse);
}
public static async Task <ServicesResponse> GetDisks(Adapter adapter)
{
ServicesResponse servicesResponse = new ServicesResponse();
if (adapter?.Credentials == null)
{
servicesResponse.errorCode = 500;
servicesResponse.errorMessage = "Adapter or credentials is null";
return(servicesResponse);
}
servicesResponse = await ApiService.GetRequest(adapter, typeof(OvirtDisk.Disks), $"ovirt-engine/api/disks");
return(servicesResponse);
}
/// <summary>
/// Get a list of all folders on the server. Optionally include default system generated folders.
/// </summary>
/// <param name="includeSystemFolders">Boolean signifying whether to include the system generated folders (currently System and Utilities) if they exist.</param>
/// <returns>List of folder names</returns>
public async Task <IEnumerable <string> > GetFolderNames(bool includeSystemFolders = false)
{
Uri rootFolderEndpoint = new Uri(ServerUrl, "services");
ServicesResponse response = await GetStringAsync <ServicesResponse>(rootFolderEndpoint);
var folders = (from folderDetail in response.foldersDetail select folderDetail.folderName);
if (!includeSystemFolders)
{
folders = (from folder in folders where folder != "System" && folder != "Utilities" select folder);
}
return(folders);
}
public static async Task <ServicesResponse> GetVMs(Adapter adapter)
{
ServicesResponse servicesResponse = new ServicesResponse();
if (adapter?.Credentials == null)
{
servicesResponse.errorCode = 500;
servicesResponse.errorMessage = "Adapter or credentials is null";
return(servicesResponse);
}
servicesResponse = await ApiService.GetRequest(adapter, typeof(Vms), "ovirt-engine/api/vms");
servicesResponse.resultObject = (Vms)servicesResponse.resultObject;
return(servicesResponse);
}
public async Task Sync()
{
List <Vm> vms = new List <Vm>();
Microsoft.EntityFrameworkCore.Query.IIncludableQueryable <Adapter, Credentials> adapters = _context.Adapters.Where(x => x.IsOK).Include(x => x.Provider).Include(a => a.Credentials);
foreach (Adapter adapter in adapters)
{
if (!adapter.IsOK)
{
break;
}
switch (adapter.Provider.Name.ToLower())
{
case "ovirt":
ServicesResponse servicesResponse = await VmService.GetFullVms(adapter);
if (!servicesResponse.isSuccess)
{
break;
}
List <Vm> commonVMs = (List <Vm>)servicesResponse.resultObject;
vms.AddRange(commonVMs);
break;
}
}
var oldVms = await _context.Vms.ToListAsync();
_context.Vms.RemoveRange(oldVms);
vms.ConvertAll(x => x.LastTimeUpdated = DateTime.Now);
_context.Vms.AddRange(vms);
//foreach (var vm in vms)
//{
// var entity = _context.Vms.Find(vm.Id);
// if (entity == null)
// {
// _context.Vms.Add(vm);
// }
// else
// {
// _context.Entry(entity).CurrentValues.SetValues(vm);
// }
//}
await _context.SaveChangesAsync();
}
public static async Task <ServicesResponse> RequestVm(Shared.Common.Vm commonVm, Adapter adapter, string networkId = null, int hddSize = 0, string dcId = null)
{
var vMRequested = Vm.CreatedVM(commonVm);
ServicesResponse servicesResponse = new ServicesResponse();
if (adapter?.Credentials == null)
{
servicesResponse.errorCode = 500;
servicesResponse.errorMessage = "Adapter or credentials is null";
return(servicesResponse);
}
servicesResponse = await ApiService.PostRequest <Vm>(adapter, vMRequested, "ovirt-engine/api/vms");
if (!servicesResponse.isSuccess || vMRequested.Template?.Name != "Blank")
{
return(servicesResponse);
}
Vm vM = (Vm)servicesResponse.resultObject;
if (vM == null)
{
throw new Exception("vm var is null but created successfully.");
}
ServicesResponse newNicResponse = await NetworkService.CreateNic(vM.Id, networkId, adapter);
if (!newNicResponse.isSuccess)
{
return(newNicResponse);
}
ServicesResponse storageDomainsRequest = await StorageDomainsService.GetStorageDomains(adapter);
if (!storageDomainsRequest.isSuccess)
{
return(storageDomainsRequest);
}
OvirtStorageDomains.StorageDomains storageDomains = (OvirtStorageDomains.StorageDomains)storageDomainsRequest.resultObject;
OvirtStorageDomains.StorageDomain storageDomain = storageDomains.StorageDomain
.FirstOrDefault(dcs => dcs.Data_centers.Data_center.Id == dcId && dcs.Master && dcs.Available > (hddSize * 20 ^ 30) && dcs.Type == "data");
ServicesResponse newDiskResponse = await DiskService.CreateDisk(vM, hddSize, storageDomain?.Id, adapter);
return(newDiskResponse);
}
/*
* request.AddParameter("name", "value"); // adds to POST or URL querystring based on Method
* //request.AddUrlSegment("id", 123); // replaces matching token in request.Resource
*
* // add parameters for all properties on an object
* request.AddObject(object);
*
* // or just whitelisted properties
* //request.AddObject(object, "PersonId", "Name", ...);
*
* // easily add HTTP Headers
* request.AddHeader("header", "value");
*
* // add files to upload (works with compatible verbs)
* //request.AddFile(path);
*
* // execute the request
* RestResponse response = client.Execute(request);
* var content = response.Content; // raw content as string
*
* // or automatically deserialize result
* // return content type is sniffed but can be explicitly set via RestClient.AddHandler();
* RestResponse<Person> response2 = client.Execute<Person>(request);
* var name = response2.Data.Name;
*
* // or download and save file to disk
* client.DownloadData(request).SaveAs(path);
*
* // easy async support
* client.ExecuteAsync(request, response => {
* Console.WriteLine(response.Content);
* });
*
* // async with deserialization
* var asyncHandle = client.ExecuteAsync<Person>(request, response => {
* Console.WriteLine(response.Data.Name);
* });
*/
private Service GetService(string serviceName, Action retryAction)
{
Service retVal = null;
System.Diagnostics.Debug.WriteLine("Get Service: {0} refresh: {1}", serviceName, this.RefreshServices);
if (this.RefreshServices)
{
this.CallGetServices((res) =>
{
this.Services = res;
this.RefreshServices = false;
if (this.ServicesReceived != null)
{
this.ServicesReceived(res);
}
retryAction();
},
(err) =>
{ });
return(retVal);
}
if (this.Services == null || this.Services.Services == null)
{
//MessageBox.Show("Please wait", "Viafo", MessageBoxButton.OK);
return(retVal);
}
foreach (var service in this.Services.Services)
{
if (service.Name == serviceName)
{
retVal = service;
break;
}
}
return(retVal);
}
public async Task <ActionResult <Adapter> > PostAdapter(Adapter adapter)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (adapter == null)
{
throw new Exception();
}
if (_context.Adapters
.Select(x => new { x.Name, x.uri })
.ToList()
.Any(x => x.uri == adapter.uri && x.Name == adapter.Name)
)
{
return(BadRequest("Адаптер с таким именем или адресом уже существует"));
}
ServicesResponse servicesResponse = new ServicesResponse();
switch (adapter.Provider?.Name)
{
case "ovirt":
servicesResponse = await EasyAdmin.Services.Ovirt.ApiService.GetRequest(adapter, "/ovirt-engine/api");
break;
}
if (servicesResponse.isSuccess)
{
adapter.IsOK = true;
adapter.Status = "Подключено";
}
else
{
adapter.IsOK = false;
adapter.Status = servicesResponse.errorMessage;
}
_context.Adapters.Add(adapter);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAdapter", new { id = adapter.Id }, adapter));
}
public async Task <IActionResult> CheckAdapter(Adapter adapter)
{
adapter = _context.Adapters.Include(x => x.Credentials).Include(x => x.Provider).SingleOrDefault(x => x.Id == adapter.Id);
ServicesResponse servicesResponse = new ServicesResponse();
if (adapter?.Provider == null)
{
return(BadRequest("Provider or adapter is null"));
}
switch (adapter.Provider.ProviderType)
{
case ProviderType.Ovirt:
servicesResponse =
await EasyAdmin.Services.Ovirt.ApiService.GetRequest(adapter, "/ovirt-engine/api");
break;
case ProviderType.VMware:
var a =
await EasyAdmin.Services.VMware.ApiService.GetRequestAsync <string>(adapter, "/status");
servicesResponse.isSuccess = a.isSuccess;
break;
}
if (servicesResponse.isSuccess)
{
adapter.IsOK = true;
adapter.Status = "Подключено";
}
else
{
adapter.IsOK = false;
adapter.Status = servicesResponse.errorMessage;
return(BadRequest(servicesResponse.errorMessage));
}
_context.Entry(adapter).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Ok(true));
}
public async Task <IActionResult> ChangeState(Vm vM)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (vM?.Adapter == null)
{
return(BadRequest());
}
Adapter adapter = await _context.Adapters.Where(x => x.IsOK)
.Include(c => c.Credentials)
.Include(p => p.Provider)
.Where(a => a.Id == vM.Adapter.Id)
.SingleOrDefaultAsync();
ServicesResponse changeStateVmResponse = new ServicesResponse();
switch (adapter.Provider.Name.ToLower())
{
case "ovirt":
string shutOrStart = vM.Status == "down" ? "start" : "shutdown";
changeStateVmResponse = await VmService.ChangeState(adapter, vM.Id, shutOrStart);
if (changeStateVmResponse.isSuccess)
{
_logger.LogInformation($"CHANGE STATUS : {vM.Status}");
_logger.LogInformation($"CHANGE STATUS : {changeStateVmResponse.resultObject}");
}
else
{
return(BadRequest(changeStateVmResponse.errorMessage));
}
break;
}
return(Ok(changeStateVmResponse));
}
public async Task <ActionResult <List <Template> > > GetTemplates(Cluster cluster)
{
if (cluster?.Datacenter?.Adapter == null)
{
return(BadRequest());
}
Adapter adapter = await _context.Adapters.Where(x => x.IsOK).Include(c => c.Credentials).Include(p => p.Provider)
.SingleOrDefaultAsync(a => a.Id == cluster.Datacenter.Adapter.Id);
if (adapter?.Provider == null)
{
return(BadRequest());
}
List <Template> templates = new List <Template>();
switch (adapter.Provider.ProviderType)
{
case ProviderType.Ovirt:
ServicesResponse servicesResponse = await TemplateService.GetTemplates(adapter);
if (servicesResponse.isSuccess)
{
OvirtTemplates ovirtTemplates = (OvirtTemplates)servicesResponse.resultObject;
ovirtTemplates.Template = ovirtTemplates.Template.Where(x => (x.Cluster?.Id == cluster.Id || x.Id == "00000000-0000-0000-0000-000000000000")).ToList();
templates.AddRange(ovirtTemplates.Template.ConvertAll(x => (Template)x));
}
break;
case ProviderType.VMware:
var response = await EasyAdmin.Services.VMware.TemplateService.GetTemplatesListAsync(adapter, cluster);
if (response.isSuccess)
{
return(response.resultObject);
}
break;
}
return(templates);
}
public static async Task <ServicesResponse <T> > GetRequestAsync <T> (Adapter adapter, string endpoint)
{
var servicesResponse = new ServicesResponse <T>();
try
{
HttpResponseMessage response = await Client.GetAsync(new Uri(adapter.uri, endpoint));
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsStringAsync();
servicesResponse.isSuccess = true;
servicesResponse.resultObject = JsonConvert.DeserializeObject <T>(result);
}
else
{
servicesResponse.errorCode = (int)response.StatusCode;
var errorMessage = await response.Content.ReadAsStringAsync();
servicesResponse.errorMessage = errorMessage;
//try
//{
// var fault = XmlDeserialize<Fault>(errorMessage);
// servicesResponse.errorMessage = fault.Detail;
//}
//catch (Exception)
//{
// servicesResponse.errorMessage = errorMessage;
//}
}
}
catch (Exception ex)
{
servicesResponse.errorCode = 500;
servicesResponse.errorMessage = ex.Message;
}
return(servicesResponse);
}
