private List <ObjectContent> debugAllProperties()
{
List <ObjectContent> listobjcontent = new List <ObjectContent>();
// RetrievePropertiesEx() returns the properties
// selected from the PropertyFilterSpec
RetrieveResult rslts = _service.RetrievePropertiesEx(_sic.propertyCollector, new PropertyFilterSpec [] { }, new RetrieveOptions());
if (rslts != null && rslts.objects != null && rslts.objects.Length != 0)
{
listobjcontent.AddRange(rslts.objects);
}
String token = null;
if (rslts != null && rslts.token != null)
{
token = rslts.token;
}
while (token != null && token.Length != 0)
{
rslts = _service.ContinueRetrievePropertiesEx(_sic.propertyCollector, token);
token = null;
if (rslts != null)
{
token = rslts.token;
if (rslts.objects != null && rslts.objects.Length != 0)
{
listobjcontent.AddRange(rslts.objects);
}
}
}
return(listobjcontent);
}
private static RetrieveResult checkResultsOfRetrieve(MetadataApiClientResponse response, string asyncId)
{
RetrieveResult result;
checkRetrieveStatusResponse responseCheck;
ConsoleHelper.WriteDocLine("Request for a deploy submitted successfully.");
ConsoleHelper.WriteDocLine("Request ID for the current deploy task: " + asyncId);
ConsoleHelper.WriteDocLine("Waiting for server to finish processing the request...");
do
{
try{
responseCheck = MetadataApiCheckRetrieveService.checkRetrieveStatus(response.Metadataclient, asyncId);
result = responseCheck.result;
ConsoleHelper.WriteDocLine("Request Status: " + result.status);
}catch (Exception e) {
result = new RetrieveResult();
ConsoleHelper.WriteErrorLine(e.Message);
}
Thread.Sleep(2000);
} while (!result.done);
return(result);
}
public RetrieveResult <WildfireAssessmentMitigationRecommendationsViewModel> RetrieveView(DataSourceRequest request, Guid mitigationRecommendationId)
{
var dbSet = context.Set <InspectionOrderWildfireAssessmentMitigationRecommendations>()
.Include(a => a.Image)
.Where(a => a.InspectionOrderWildfireAssessmentMitigation.Id == mitigationRecommendationId)
.OrderBy(a => a.Image.CreatedAt);
var resultList = Retrieve(dbSet, request);
var mitigationList = new RetrieveResult <WildfireAssessmentMitigationRecommendationsViewModel>();
mitigationList.PageNo = resultList.PageNo;
mitigationList.SortBy = resultList.SortBy;
mitigationList.RecordPage = resultList.RecordPage;
mitigationList.TotalRecords = resultList.TotalRecords;
mitigationList.Results = resultList.Results.Select(mitigation => new WildfireAssessmentMitigationRecommendationsViewModel
{
InspectionOrderWildfireAssessmentMitigationId = mitigation.InspectionOrderWildfireAssessmentMitigationId,
InspectionOrderWildfireAssessmentMitigation = mitigation.InspectionOrderWildfireAssessmentMitigation,
Id = mitigation.Id,
Description = mitigation.Description,
ImageId = mitigation.ImageId,
Image = mitigation.Image,
ChildMitigation = mitigation.ChildMitigation,
ChildMitigationCount = _inspectionOrderWildfireAssessmentChildMitigationRecommendationsRepository.childMitigationCount(mitigation.Id),
Status = mitigation.Status
}).ToList();
return(mitigationList);
}
public RetrieveResult CheckRetrieveStatus(string asyncProcessId, bool includeZip)
{
RetrieveResult retrieveResult = null;
retrieveResult = _service.checkRetrieveStatus(asyncProcessId, includeZip);
return(retrieveResult);
}
private static void printMessages(RetrieveResult result, bool isHaveMessages)
{
if (isHaveMessages)
{
foreach (RetrieveMessage rm in result.messages)
{
ConsoleHelper.WriteWarningLine(rm.fileName + " " + rm.problem);
}
}
}
public override Task <IRetrieveResult <BacktestResult> > RetrieveImpl()
{
if (_object == null && Path != null)
{
try
{
_object = Newtonsoft.Json.JsonConvert.DeserializeObject <BacktestResult>(System.IO.File.ReadAllText(Path));
if (_object.AD == 0.0)
{
_object.AD = this.AD;
}
}
catch { }
}
return(Task.FromResult(HasObject ? (IRetrieveResult <BacktestResult>)RetrieveResult <BacktestResult> .Success(_object) : RetrieveResult <BacktestResult> .NotFound));
}
public RetrieveResult <TEntity> Retrieve <TEntity>(IQueryable <TEntity> queryable, DataSourceRequest request) where TEntity : class
{
var dataSourceResult = queryable.AsNoTracking().ToDataSourceResult(request);
var result = new RetrieveResult <TEntity>
{
Results = dataSourceResult.Data.Cast <TEntity>().ToList()
};
if (result.Results.Count <= 0)
{
return(result);
}
result.TotalRecords = dataSourceResult.Total;
result.PageNo = request.Skip / request.Take;
result.RecordPage = request.Take;
return(result);
}
private static void extractFile(RetrieveResult result)
{
bool isStatusFailed = result.status == RetrieveStatus.Failed;
bool isStatusSucceeded = result.status == RetrieveStatus.Succeeded;
bool isHaveMessages = result.messages != null;
if (isStatusFailed)
{
ConsoleHelper.WriteErrorLine(result.errorMessage);
}
else if (isStatusSucceeded)
{
printMessages(result, isHaveMessages);
String pathDirectory = Environment.CurrentDirectory + @"\package";
createDirectoryPathPackage(pathDirectory);
generateZipFile(result, pathDirectory);
ConsoleHelper.WriteDoneLine("Finalize Success Retrieve!");
}
}
public override Task <IRetrieveResult <BacktestResult> > RetrieveImpl()
{
if (_object == null && Path != null)
{
#if NewtonsoftJson
try
{
_object = Newtonsoft.Json.JsonConvert.DeserializeObject <BacktestResult>(System.IO.File.ReadAllText(Path));
if (_object.AD == 0.0)
{
_object.AD = this.AD;
}
}
catch { }
#else
throw new NotImplementedException("TODO: JSON deserialize");
#endif
}
return(Task.FromResult(HasValue ? (IRetrieveResult <BacktestResult>)RetrieveResult <BacktestResult> .Success(_object) : RetrieveResult <BacktestResult> .NotFound));
}
public RetrieveResult CheckRetrieveResult(string id)
{
RetrieveResult retrieveResult = null;
try
{
retrieveResult = SessionExpirationWrapper(() => _metadataServiceAdapter.CheckRetrieveStatus(id, true));
}
catch (SoapException ex)
{
if (ex.Message != "INVALID_ID_FIELD: Deployment still in process: InProgress")
{
if (ex.Message != "INVALID_ID_FIELD: Deployment still in process: Queued")
{
Log.Error(ex.Message);
throw;
}
}
}
return(retrieveResult);
}
public static async Task <RetrieveResult> TryRetrieve(string key)
{
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Add("apikey", API_KEY);
string serverUrl = "https://api.screenshotapi.io/retrieve?key=" + key;
Console.WriteLine("Downloading:" + serverUrl);
var response = await httpClient.GetAsync(serverUrl).ConfigureAwait(false);
if (response.StatusCode == HttpStatusCode.OK)
{
var result = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var jsonResults = JsonConvert.DeserializeObject <dynamic>(result);
RetrieveResult retResult = new RetrieveResult();
//{ "status":"ready","imageUrl":"http://screenshotapi.s3.amazonaws.com/captures/f469a4c54b4852b046c6f210935679ae.png"}
if (jsonResults.status == "ready")
{
retResult.Success = true;
WebClient client = new WebClient();
string downloadUrl = jsonResults.imageUrl;
retResult.Bytes = client.DownloadData(downloadUrl);
}
else
{
retResult.Success = false;
}
return(retResult);
}
else
{
Console.WriteLine("Invalid Status Received:" + response.StatusCode);
}
}
return(null);
}
public static List <SalesforceFileProxy> DownloadAllFilesSynchronously(PackageEntity package, SalesforceContext ctx, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (!ctx.IsLoggedIn)
{
throw new InvalidOperationException("Service should be logged into Salesforce");
}
List <SalesforceFileProxy> listFileProxies = new List <SalesforceFileProxy>();
RetrieveRequest[] retrieveRequestArray = ConvertPackageToRequests(package);
List <AsyncResult> listResults = new List <AsyncResult>();
foreach (var retrieveRequest in retrieveRequestArray)
{
RetrieveRequest request = retrieveRequest;
cancellationToken.ThrowIfCancellationRequested();
AsyncResult asyncResult = ctx.SessionExpirationWrapper(() => ctx.MetadataServiceAdapter.Retrieve(request));
listResults.Add(asyncResult);
}
cancellationToken.ThrowIfCancellationRequested();
ICollection <Task <RetrieveResult> > collection = new Collection <Task <RetrieveResult> >();
foreach (var asyncResult in listResults)
{
cancellationToken.ThrowIfCancellationRequested();
Task <RetrieveResult> task = Task <RetrieveResult> .Factory.StartNew(() => ctx.PollingResult.PollForResultWrapper(3, 180, 3, () =>
ctx.CheckRetrieveResult(asyncResult.id), res => res != null, cancellationToken), cancellationToken);
collection.Add(task);
}
ctx.WaitAllTaskskWithHandlingAggregateException(collection.ToArray(), cancellationToken);
foreach (Task <RetrieveResult> task in collection)
{
cancellationToken.ThrowIfCancellationRequested();
RetrieveResult result = task.Result;
string fileName = String.Format("{0}\\{1}.zip", ctx.OutputLocation, Guid.NewGuid().ToString());
bool rawZip = Boolean.Parse(ConfigurationManager.AppSettings["salesforcemigrations:dumprawzip"]);
if (rawZip)
{
var rawZipFile = new SalesforceFileProxy
{
FullName = result.id,
FileName = String.Format("unpackaged/zips/{0}.zip", result.id),
Type = "zip",
BinaryBody = result.zipFile
};
listFileProxies.Add(rawZipFile);
}
List <SalesforceFileProxy> files = UnzipPackageFilesHelper.UnzipPackageFilesRecursive(result.zipFile);
UpdateFileProperties(files, result.fileProperties);
listFileProxies.AddRange(files);
}
return(listFileProxies);
}
public IReadOnlyCollection <string> GetVirtualMachineNames()
{
EnsureConnected();
ServiceContent serviceContent = _connection.ServiceContent;
ManagedObjectReference viewManager = serviceContent.viewManager;
ManagedObjectReference propertyCollector = serviceContent.propertyCollector;
ManagedObjectReference containerView = _connection.Service.CreateContainerView(viewManager,
serviceContent.rootFolder, new[] { "VirtualMachine" }, true);
TraversalSpec traversalSpec = new TraversalSpec()
{
name = "traverseEntities",
type = "ContainerView",
path = "view",
skip = false
};
ObjectSpec objectSpec = new ObjectSpec
{
obj = containerView,
skip = true
};
objectSpec.selectSet = new SelectionSpec[] { traversalSpec };
PropertySpec propertySpec = new PropertySpec()
{
type = "VirtualMachine",
pathSet = new [] { "name" }
};
PropertyFilterSpec filter = new PropertyFilterSpec()
{
objectSet = new[] { objectSpec },
propSet = new[] { propertySpec }
};
RetrieveOptions retrieveOptions = new RetrieveOptions();
RetrieveResult properties = _connection.Service.RetrievePropertiesEx(propertyCollector, new[] { filter },
retrieveOptions);
var virtualMachineNames = new List <string>();
if (properties != null)
{
foreach (ObjectContent objectContent in properties.objects)
{
DynamicProperty[] dynamicProperties = objectContent.propSet;
if (dynamicProperties != null)
{
foreach (DynamicProperty dynamicProperty in dynamicProperties)
{
string virtualMachineName = (string)dynamicProperty.val;
string path = dynamicProperty.name;
virtualMachineNames.Add(virtualMachineName);
}
}
}
}
return(virtualMachineNames);
}
private static void generateZipFile(RetrieveResult result, string pathDirectory)
{
String pathFile = pathDirectory + @"\package.zip";
File.WriteAllBytes(pathFile, result.zipFile);
}
