public static StackHashEventCollection GetEventsApi(ref Login login, ApplicationFile file, out List <Event> rawEvents, DateTime startTime)
{
EventPageReader eventPageReader = file.GetEvents(startTime); // Get all events.
StackHashEventCollection apiStackHashEvents = new StackHashEventCollection();
rawEvents = new List <Event>();
// Read each page of new events.
while (eventPageReader.Read(ref login) == true)
{
// Get the events for the page.
EventReader events = eventPageReader.Events;
while (events.Read() == true)
{
// Get the event
Event dpEvent = events.Event;
rawEvents.Add(dpEvent);
StackHashEvent stackHashEvent = ObjectConversion.ConvertEvent(dpEvent, file.ID);
apiStackHashEvents.Add(stackHashEvent);
}
}
return(apiStackHashEvents);
}
public ActionResult <Application> PostApplication([FromForm] ApplicationFile appFile, [FromForm] Application app)
{
//appending date with filename to make dbo.Application.File_Name unique
string tempFileName = DateTime.Now.ToString("dddd, dd MMMM yyyy HH:mm:ss") + "/" + app.FileName;
DatabaseOperation db = new DatabaseOperation();
db.AddApplication(app.ProjectName, app.CategoryName, tempFileName);
Application application = new Application();
DatabaseOperation db1 = new DatabaseOperation();
application = db1.GetSingleApplication(app.ProjectName, app.CategoryName, tempFileName);
DatabaseOperation db2 = new DatabaseOperation();
Project project = db2.GetSingleProject(app.ProjectName)[0];
FileHierarchyCreation file = new FileHierarchyCreation();
bool uploadCheck = file.CreateApplicationFolder(application.AppId, app.CategoryName, app.ProjectName, tempFileName, project.BundleIdentifier, appFile);
if (uploadCheck)
{
return(StatusCode(200, new { title = "Applicaton uploaded successfully.", status = 200 }));
}
else
{
return(StatusCode(500, new { title = "Applicaton upload error.", status = 500, message = "This app version already exists" }));
}
}
public RecompensateApplicationProcessCommand(
string id,
ApplicationFile photo,
ApplicationFile cv)
{
Id = id;
Photo = photo;
Cv = cv;
}
/// <summary>
/// Initializes a new instance of <see cref="Packager"/>.
/// </summary>
/// <param name="applicationData">The data to base the packaging process on.</param>
/// <param name="outputFolder">The location where the application must be packaged to.</param>
public Packager(ApplicationData applicationData, string outputFolder)
{
var workingDirectory = new ApplicationFile(outputFolder);
if (workingDirectory.Type != FileType.Directory)
{
throw new ArgumentException("The value specified for the outputFolder is invalid.", "outputFolder");
}
_startInfo = new VirtualProcessStartInfo(applicationData, workingDirectory);
_waitHandle = new AutoResetEvent(false);
}
private void downloadFile(ApplicationFile file)
{
Response.Clear();
Response.Buffer = true;
Response.Charset = "";
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.ContentType = file.ContentType;
Response.AppendHeader("Content-Disposition", "attachment; filename=" + file.FileName);
//Response.BinaryWrite(file.data);
Response.Flush();
Response.End();
}
public static string getFilePath(ApplicationFile f)
{
switch (f)
{
case ApplicationFile.EmptyDB:
return string.Format(@"{0}\{1}", getFolderPath(ApplicationFolder.Defaults), MOBILEDB_FILE);
case ApplicationFile.EmptyTaxonDB:
return string.Format(@"{0}\{1}", getFolderPath(ApplicationFolder.Defaults), TAXONDB_FILE);
case ApplicationFile.ConnectionProfiles:
return string.Format(@"{0}\{1}", getFolderPath(ApplicationFolder.Defaults), CONNECTIONPROFILES_FILE);
default:
throw new ArgumentException("Unkown FileType");
}
}
/// <summary>
/// Extract zip release file to application directory.
/// </summary>
/// <param name="releaseFile">A zip release file.</param>
protected void ExtractRelease(FileInfo releaseFile)
{
try
{
GRoggle.Write("Try to extract a release zip", RoggleLogLevel.Debug);
ZipFile.ExtractToDirectory(releaseFile.FullName, ApplicationDirectory.FullName);
File.Delete(releaseFile.FullName);
ApplicationFile.Refresh();
}
catch (Exception e)
{
GRoggle.Write("Something goes wrong while extracting release", e);
}
}
public static string getFilePath(ApplicationFile f)
{
switch (f)
{
case ApplicationFile.EmptyDB:
return(string.Format(@"{0}\{1}", getFolderPath(ApplicationFolder.Defaults), MOBILEDB_FILE));
case ApplicationFile.EmptyTaxonDB:
return(string.Format(@"{0}\{1}", getFolderPath(ApplicationFolder.Defaults), TAXONDB_FILE));
case ApplicationFile.ConnectionProfiles:
return(string.Format(@"{0}\{1}", getFolderPath(ApplicationFolder.Defaults), CONNECTIONPROFILES_FILE));
default:
throw new ArgumentException("Unkown FileType");
}
}
/// <summary>
/// Converts a WinQual ApplicationFile into a StackHashFile.
/// </summary>
/// <param name="file">WinQual application file to convert.</param>
/// <returns>Converted file.</returns>
public static StackHashFile ConvertFile(ApplicationFile file)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
StackHashFile newFile = new StackHashFile(
file.DateCreatedLocal.ToUniversalTime(),
file.DateModifiedLocal.ToUniversalTime(),
file.ID,
file.LinkDateLocal.ToUniversalTime(),
file.Name,
file.Version);
return(newFile);
}
public ImageVM GetImage(int id)
{
ApplicationFile file = new ApplicationFile();
file = ApplicationFileRepository.GetImage(id);
if (file == null)
{
throw new BussinesException(502, ErrorResource.NoData);
}
ImageVM result = new ImageVM
{
Content = file.Content,
Type = file.ContentType
};
return(result);
}
/// <summary>
///
/// </summary>
/// <exception cref="FileNotFoundException"></exception>
/// <exception cref="GacException"></exception>
/// <param name="otherAppExe"></param>
/// <param name="sharedAssemblies"></param>
public GacManager(string otherAppExe, IEnumerable <string> sharedAssemblies)
{
_gacSyncRoot = new object();
_otherAppExe = new ApplicationFile(otherAppExe);
if (_otherAppExe.Type != FileType.Executable)
{
throw new GacException("\"" + _otherAppExe.FileName + "\" is no valid executable.");
}
_sharedAssemblies = new List <ApplicationFile>();
foreach (var sharedAssembly in sharedAssemblies)
{
var file = new ApplicationFile(sharedAssembly);
if (file.Type == FileType.Library)
{
_sharedAssemblies.Add(file);
}
}
}
/// <summary>
/// Initializes a new instance of <see cref="ProcessSynchronizer"/>.
/// The constructor will create default databases from the specified files.
/// </summary>
/// <param name="fileSystemRoot">The directory to use as root of the file system.</param>
/// <param name="fileSystemRuleCollection">The collection of engine rules to apply on the file system virtualization engine.</param>
/// <param name="registryDatabaseFile">The file to use with a default <see cref="RegistryDatabase"/>.</param>
/// <param name="registryRuleCollection">The collection of engine rules to apply on the registry virtualization engine.</param>
public ProcessSynchronizer(ApplicationFile fileSystemRoot, FileSystemRuleCollection fileSystemRuleCollection,
ApplicationFile registryDatabaseFile, RegistryRuleCollection registryRuleCollection)
{
if (fileSystemRoot.Type != FileType.Directory)
{
throw new ArgumentException("The root location specified for the file system is not valid.", "fileSystemRoot");
}
if (registryDatabaseFile.Type != FileType.Database)
{
throw new ArgumentException("The filename specified for the registry database is not valid.", "registryDatabaseFile");
}
_connectionStrings = new Dictionary <ConfigurationDataType, string>(2)
{
{ ConfigurationDataType.RegistryDatabaseFile, registryDatabaseFile.FileName },
{ ConfigurationDataType.FileSystemRoot, fileSystemRoot.FileName }
};
_fsRuleCollection = fileSystemRuleCollection;
_regRuleCollection = registryRuleCollection;
}
/// <summary>
/// Initializes a new instance of <see cref="VirtualProcessStartInfo"/>
/// based on the <see cref="ApplicationData"/> specified.
/// </summary>
/// <exception cref="ArgumentNullException">
/// An <see cref="ArgumentNullException"/> is thrown if <paramref name="data"/> of one of its properties is null.
/// </exception>
/// <exception cref="ArgumentException">
/// An <see cref="ArgumentException"/> is thrown if any of the properties of <paramref name="data"/> is of the wrong type.
/// </exception>
/// <param name="data">The data to base the process on.</param>
/// <param name="workingDirectory">The working directory of the process to start.</param>
public VirtualProcessStartInfo(ApplicationData data, ApplicationFile workingDirectory)
{
if (data == null ||
data.Files.RegistryDatabase == null ||
data.Files.Executable == null ||
data.Files.RootDirectory == null)
{
throw new ArgumentNullException("data", "The data argument or one of its properties is null.");
}
if (workingDirectory == null)
{
throw new ArgumentNullException("workingDirectory", "The workingDirectory argument is null.");
}
if (data.Files.Executable.Type != FileType.Executable)
{
throw new ArgumentException("The ApplicationData specified contains an illegal value for the main executable.",
"data");
}
if (data.Files.RegistryDatabase.Type != FileType.Database)
{
throw new ArgumentException(
"The ApplicationData specified contains an illegal value for the registry database.",
"data");
}
if (workingDirectory.Type != FileType.Directory)
{
throw new ArgumentException("The working directory specified is not a directory.",
"workingDirectory");
}
_files = new ApplicationFiles
{
RegistryDatabase
= new ApplicationFile(Path.Combine(workingDirectory.FileName, data.Files.RegistryDatabase.FileName)),
Executable
= new ApplicationFile(Path.Combine(workingDirectory.FileName, data.Files.Executable.FileName)),
RootDirectory
= new ApplicationFile(Path.Combine(workingDirectory.FileName, data.Files.RootDirectory.FileName))
};
_arguments = "";
_workingDirectory = workingDirectory;
_fileSystemRuleCollection = data.Settings.FileSystemEngineRuleCollection ?? FileSystemRuleCollection.GetDefaultRuleCollection();
_registryRuleCollection = data.Settings.RegistryEngineRuleCollection ?? RegistryRuleCollection.GetDefaultRuleCollection();
}
/// <summary>
/// Starts a process from the <see cref="ApplicationData"/> loaded from the filename specified.
/// </summary>
/// <exception cref="FileNotFoundException">
/// A <see cref="FileNotFoundException"/> is thrown if the <paramref name="applicationDataFile"/> can not be found.
/// </exception>
/// <exception cref="HostException">
/// A <see cref="HostException"/> is thrown if the process can't be started.
/// </exception>
/// <param name="applicationDataFile">
/// The file to load the <see cref="ApplicationData"/> from,
/// representing the application to start.
/// </param>
public static void StartProcess(string applicationDataFile)
{
if (!File.Exists(applicationDataFile))
{
throw new FileNotFoundException("Unable to locate the virtual application's datafile.", applicationDataFile);
}
var data = ApplicationData.Load(applicationDataFile);
if (data == null)
{
throw new HostException("\"" + applicationDataFile + "\""
+ " could not be found or contains invalid data while trying"
+ " to start a new process based on this file.");
}
var workingDirectory = new ApplicationFile(Path.GetDirectoryName(applicationDataFile));
var startInfo = new VirtualProcessStartInfo(data, workingDirectory);
_process = VirtualizedProcess.Start(startInfo);
}
public bool UploadApplicationFile(string route, ApplicationFile appFile)
{
if (appFile.File.Length > 0)
{
try
{
using (FileStream filestream = System.IO.File.Create(route + "/" + appFile.File.FileName))
{
appFile.File.CopyTo(filestream);
filestream.Flush();
return(true);
}
}
catch (Exception e)
{
Console.WriteLine("Upload Application File catch" + e);
}
}
return(false);
}
public IHttpActionResult AddApplicationFile(ApplicationFile value)
{
var result = objApplicationFileRepository.Save(value);
return(Ok(result));
}
private ApplicationDefinition CreateApplicationDefinition(List <Reference> references, IEnumerable <PackageFile> files)
{
var defaultEnvironments = DefaultEnvironments.Select(
e => ( TargetEnvironment )Enum.Parse(typeof(TargetEnvironment), e));
var scripts = files.Where(f => f.Environment != TargetEnvironment.None);
var specifiedEnvironments = scripts.Where(f => f.Environment != TargetEnvironment.All).Select(f => f.Environment).Distinct();
specifiedEnvironments = specifiedEnvironments.Union(defaultEnvironments);
Guid = Guid.Replace("{", "").Replace("}", "");
ApplicationDefinition appdef = new ApplicationDefinition
{
Name = ApplicationName,
Guid = Guid,
Version = ApplicationVersion,
Description = Description,
Publisher = Publisher,
Copyright = Copyright,
RequiredMFilesVersion = MFilesVersion,
EnabledByDefault = EnabledByDefault,
Optional = Optional,
MasterApplicationGuid = MasterApplicationGuid,
Platforms = Platforms.Select(platformName => new Platform(platformName)).ToList()
};
// Create the module elements.
foreach (var env in specifiedEnvironments)
{
var module = new ApplicationModule {
Environment = env.ToString().ToLower()
};
appdef.Modules.Add(module);
// Add the bootstrap scripts.
module.Files.Add(new ApplicationFile {
Name = "_package_start.js"
});
// Add javascript files from the references.
foreach (var r in references)
{
var referencedScripts = r.GetScriptsForEnvironment(env);
foreach (var script in referencedScripts)
{
var file = new ApplicationFile {
Name = r.PackageName + "/" + script
};
module.Files.Add(file);
}
}
// Add the application's own javascript files.
var environmentScripts = scripts.Where(s => s.Environment == TargetEnvironment.All || s.Environment == env);
foreach (var script in environmentScripts)
{
var file = new ApplicationFile {
Name = script.PathInProject
};
module.Files.Add(file);
}
module.Files.Add(new ApplicationFile {
Name = "_package_end.js"
});
}
foreach (var db in files.Where(f => f.IsDashboard))
{
var dashboard = new ApplicationDashboard
{
Id = Path.GetFileNameWithoutExtension(db.PathInProject),
Content = db.PathInProject
};
appdef.Dashboards.Add(dashboard);
}
foreach (var r in references)
{
foreach (var db in r.GetDashboards())
{
var dashboard = new ApplicationDashboard
{
Id = db.Key,
Content = r.PackageName + "/" + db.Value
};
appdef.Dashboards.Add(dashboard);
}
}
return(appdef);
}
public bool CreateApplicationFolder(int appId, string categoryName, string projectName, string fileName, string bundleIdentifier, ApplicationFile appFile)
{
string applicationPath = rootPath + "/" + projectName + "/" + categoryName + "/" + Convert.ToString(appId);
string ipaPath = ipaRootPath + "/" + projectName + "/" + categoryName + "/" + Convert.ToString(appId);
// Console.WriteLine(applicationPath);
CreateCategoryFolder(projectName, categoryName);
if (FileExists(applicationPath) == false)
{
System.IO.Directory.CreateDirectory(applicationPath);
if (UploadApplicationFile(applicationPath, appFile))
{
FileOperationLibrary.ManifestPlist manifest = new FileOperationLibrary.ManifestPlist();
manifest.CreateManifest(applicationPath, ipaPath + "/" + appFile.File.FileName, bundleIdentifier, Convert.ToString(appId), projectName);
}
else
{
// Console.WriteLine("file upload error");
return(false);
}
return(true);
}
return(false);
}
/// <summary>
/// Method to loads the mapped files associated with the mapped product.
/// </summary>
/// <param name="loginObject">Object containing the login credentials.</param>
/// <returns>Collection of MappedFile objects.</returns>
public MappedFileCollection GetMappedFiles(ref Login loginObject)
{
//
// get the feed response string
//
string responseFromServer = ApplicationFile.GetFeedResponse(new Uri(BASE_URL + "mappedproductfiles.aspx?mappedproductid=" + this.ID.ToString()), ref loginObject);
XmlNamespaceManager namespaceMgr;
//
// get the entry nodes from the XML
//
XmlNodeList entryNodes = ApplicationFile.GetEntryNodes(responseFromServer, out namespaceMgr);
//
// create an empty mapped file collection object.
//
MappedFileCollection mappedFileCollection = new MappedFileCollection(entryNodes.Count);
//
// parse the entry elements and load the product objects
//
foreach (XmlNode entryNode in entryNodes)
{
MappedFile mappedFile = new MappedFile();
//title - file name
mappedFile.Name = entryNode.SelectSingleNode("atom:title", namespaceMgr).InnerText;
//id - file id
mappedFile.ID = int.Parse(entryNode.SelectSingleNode("atom:id", namespaceMgr).InnerText);
// updated - file date modified
mappedFile.DateModifiedLocal = DateTime.Parse(entryNode.SelectSingleNode("atom:updated", namespaceMgr).InnerText).ToLocalTime();
// published - file date created
mappedFile.DateCreatedLocal = DateTime.Parse(entryNode.SelectSingleNode("atom:published", namespaceMgr).InnerText).ToLocalTime();
// link - href - events link
//mappedFile.EventsLink = new Uri(entryNode.SelectSingleNode("atom:link", namespaceMgr).Attributes["href"].Value);
// file version
mappedFile.Version = entryNode.SelectSingleNode("wer:fileVersion", namespaceMgr).InnerText;
// file link date
mappedFile.LinkDateLocal = DateTime.Parse(entryNode.SelectSingleNode("wer:fileLinkDate", namespaceMgr).InnerText).ToLocalTime();
// mapped by
mappedFile.MappedBy = entryNode.SelectSingleNode("wer:mappedBy", namespaceMgr).InnerText;
// mapped by e-mail
mappedFile.MappedByEmail = entryNode.SelectSingleNode("wer:mappedByEmail", namespaceMgr).InnerText;
// status
mappedFile.Status = entryNode.SelectSingleNode("wer:status", namespaceMgr).InnerText;
//
// add the file to the file collection
//
mappedFileCollection.Add(mappedFile);
}
//
// return the file collection
//
return(mappedFileCollection);
}
public ActionResult SaveResume(HttpPostedFileBase file, Guid id = new Guid())
{
try {
JobBoardDataContext db = new JobBoardDataContext();
Application app = db.Applications.Where(x => x.id.Equals(id)).FirstOrDefault<Application>();
if (file != null && file.ContentLength > 0) {
string fileName = Path.GetFileName(file.FileName);
string name = (Request.Form["name"] != null && Request.Form["name"].Length > 0) ? Request.Form["name"] : "";
Stream uploadedFile = file.InputStream;
int slength = Convert.ToInt32(uploadedFile.Length);
byte[] fileData = new byte[slength];
uploadedFile.Read(fileData, 0, slength);
uploadedFile.Close();
ApplicationFile afile = new ApplicationFile {
id = Guid.NewGuid(),
app_id = app.id,
fileName = fileName,
name = name,
size = fileData.Length,
fileContent = fileData
};
if (afile.isTypeAllowed() && afile.isSizeAllowed()) {
db.ApplicationFiles.InsertOnSubmit(afile);
db.SubmitChanges();
} else {
if (!afile.isSizeAllowed()) {
throw new Exception("File is too large!");
}
if (!afile.isTypeAllowed()) {
throw new Exception("File type not allowed!");
}
}
}
return Redirect("/Job/Resume/" + id);
} catch (Exception e) {
TempData["error"] = e.Message;
return Redirect("/Job/Resume/" + id);
}
}
private void UpdateEvents(DateTime lastPullDate, IErrorIndex errorIndex,
StackHashProduct stackHashProduct, bool getCabs, ApplicationFile file, StackHashFile stackHashFile)
{
// Get the events for the file with the start date as last pull date + 1.
// Only stores the last 90 days worth - this will exception if you specify a date
// before that time. In the case of the last pulldown date being close to 90 days ago
// just get ALL the events.
DateTime startTime = lastPullDate; // This is a local time.
EventPageReader eventPageReader;
TimeSpan timeSinceLastSync = (DateTime.UtcNow - lastPullDate.ToUniversalTime());
if (timeSinceLastSync.Days >= 89)
{
StackHashUtilities.DiagnosticsHelper.LogMessage(DiagSeverity.Information,
String.Format(CultureInfo.InvariantCulture, "Updating Events for {0} {1} ALL",
stackHashProduct.Name, stackHashFile.Name));
eventPageReader = file.GetEvents(); // Get all events.
}
else
{
StackHashUtilities.DiagnosticsHelper.LogMessage(DiagSeverity.Information,
String.Format(CultureInfo.InvariantCulture, "Updating Events for {0} {1} since {2} {3}",
stackHashProduct.Name, stackHashFile.Name, startTime, startTime.Kind));
eventPageReader = file.GetEvents(startTime);
}
// Read each page of new events.
while (eventPageReader.Read(ref m_Login) == true)
{
if (m_AbortRequested)
{
throw new OperationCanceledException("Abort requested during Win Qual synchronize");
}
// Get the events for the page.
EventReader events = eventPageReader.Events;
while (events.Read() == true)
{
if (m_AbortRequested)
{
throw new OperationCanceledException("Abort requested during Win Qual synchronize");
}
// Get the event
Event dpEvent = events.Event;
StackHashEvent stackHashEvent = ObjectConversion.ConvertEvent(dpEvent, stackHashFile.Id);
m_SyncProgress.EventId = stackHashEvent.Id;
m_SyncProgress.EventTypeName = stackHashEvent.EventTypeName;
// Check the date created. If it is greater than the last
// pull date then this is a new event and hence insert.
if (dpEvent.DateCreatedLocal > lastPullDate)
{
errorIndex.AddEvent(stackHashProduct, stackHashFile, stackHashEvent);
}
else if (dpEvent.DateModifiedLocal > lastPullDate)
{
// update the event information if event modified
// date is greater than the last pull date
errorIndex.AddEvent(stackHashProduct, stackHashFile, stackHashEvent);
}
else
{
// Check if the event exists. If not then add it.
if (!errorIndex.EventExists(stackHashProduct, stackHashFile, stackHashEvent))
{
errorIndex.AddEvent(stackHashProduct, stackHashFile, stackHashEvent);
}
}
// Get the details for the event.
EventInfoCollection infoCollection = dpEvent.GetEventDetails(ref m_Login);
// Loop through the event info.
StackHashEventInfo stackHashEventInfo = null;
StackHashEventInfoCollection stackHashEventInfoCollection = new StackHashEventInfoCollection();
foreach (EventInfo info in infoCollection)
{
if (m_AbortRequested)
{
throw new OperationCanceledException("Abort requested during Win Qual synchronize");
}
stackHashEventInfo = ObjectConversion.ConvertEventInfo(info);
stackHashEventInfoCollection.Add(stackHashEventInfo);
}
errorIndex.MergeEventInfoCollection(stackHashProduct, stackHashFile, stackHashEvent, stackHashEventInfoCollection);
// Now get the total hits.
StackHashEventInfoCollection newEventInfos = errorIndex.LoadEventInfoList(stackHashProduct, stackHashFile, stackHashEvent);
int hits = 0;
foreach (StackHashEventInfo theEvent in newEventInfos)
{
hits += theEvent.TotalHits;
}
// Update the hits count.
stackHashEvent.TotalHits = hits;
errorIndex.AddEvent(stackHashProduct, stackHashFile, stackHashEvent);
if (getCabs)
{
UpdateCabs(lastPullDate, errorIndex, stackHashProduct, dpEvent, stackHashFile, stackHashEvent);
}
}
}
}
public void GetEventsStartDate()
{
DateTime startTime = DateTime.Now.AddMonths(-1);
AtomFeed atomFeed = new AtomFeed(null, 1, 100000, false, false, null, 11);
// ATOM LOGIN.
Assert.AreEqual(true, atomFeed.Login(TestSettings.WinQualUserName, TestSettings.WinQualPassword));
// ATOM GetProducts.
AtomProductCollection atomProducts = atomFeed.GetProducts();
// WERAPI Login.
Login login = new Login(TestSettings.WinQualUserName, TestSettings.WinQualPassword);
login.Validate();
// WERAPI GetProducts.
ProductCollection apiProducts = Product.GetProducts(ref login);
Assert.AreEqual(atomProducts.Count, apiProducts.Count);
bool eventListsDifferent = false;
foreach (AtomProduct atomProduct in atomProducts)
{
// ATOM GetFiles.
AtomFileCollection atomFiles = atomFeed.GetFiles(atomProduct);
// API GetFiles
Product apiProduct = Utils.FindProduct(apiProducts, atomProduct.Product.Id);
ApplicationFileCollection apiFiles = apiProduct.GetApplicationFiles(ref login);
Assert.AreEqual(atomFiles.Count, apiFiles.Count);
foreach (AtomFile atomFile in atomFiles)
{
ApplicationFile apiFile = Utils.FindFile(apiFiles, atomFile.File.Id);
// ATOM GetEvents.
StackHashEventCollection atomStackHashEvents = Utils.GetEventsAtom(atomFeed, atomFile, startTime);
StackHashEventCollection atomStackHashEventsNoTime = Utils.GetEventsAtom(atomFeed, atomFile);
if (atomStackHashEvents.Count != atomStackHashEventsNoTime.Count)
{
eventListsDifferent = true;
}
// WERAPI GetEvents.
List <Event> rawApiEvents;
StackHashEventCollection apiStackHashEvents = Utils.GetEventsApi(ref login, apiFile, out rawApiEvents, startTime);
Assert.AreEqual(apiStackHashEvents.Count, atomStackHashEvents.Count);
foreach (StackHashEvent stackHashEvent in atomStackHashEvents)
{
// Find the equivalent event in the api file list.
StackHashEvent apiEvent = apiStackHashEvents.FindEvent(stackHashEvent.Id, stackHashEvent.EventTypeName);
Assert.AreNotEqual(null, apiEvent);
Assert.AreEqual(true, stackHashEvent.CompareTo(apiEvent) == 0);
}
}
}
Assert.AreEqual(true, eventListsDifferent);
}
