private void Length_Validating(object sender, CancelEventArgs e)
{
var validator = new TrackValidator();
var result = validator.LengthCheck(txtLength.Text);
errorProviderLength.SetError(txtLength, result.Message);
e.Cancel = !result.IsValid;
}
private void Name_Validating(object sender, CancelEventArgs e)
{
var validator = new TrackValidator();
var result = validator.NameCheck(txtName.Text);
errorProviderName.SetError(txtName, result.Message);
e.Cancel = !result.IsValid;
}
private void cbMainArtist_Validating(object sender, CancelEventArgs e)
{
var trackArtists = lbFeaturedArtists.Items.Cast <Model.Artist>().Select(i => i.ID).ToList();
var mainArtist = Convert.ToInt32(cbMainArtist.SelectedValue);
var validator = new TrackValidator();
var result = validator.MainArtistCheck(mainArtist, trackArtists);
errorProviderMainArtist.SetError(cbMainArtist, result.Message);
e.Cancel = !result.IsValid;
}
public void ProcessTracks(Track[] tracks)
{
foreach (var track in tracks)
{
//download the invalid track file
var trackFileName = string.Format(@"{0}\{1}{2}", m_stagingDirectory, track.TrackName.Trim(), Path.GetExtension(track.TrackUrl)).Replace("+", " ");
using (WebClient client = new WebClient())
{
Console.WriteLine(string.Format("Downloading {0}", track.TrackUrl));
client.DownloadFile(track.TrackUrl, trackFileName);
}
bool slot8 = false;
using (ZipArchive archive = ZipFile.OpenRead(trackFileName))
{
string databaseExt = ".dx9.database";
string levelExt = ".dx9.level";
string packageExt = ".dx9.package";
string sceneExt = ".dx9.scene";
foreach (ZipArchiveEntry entry in archive.Entries)
{
if (entry.Name.EndsWith(databaseExt, StringComparison.OrdinalIgnoreCase) ||
entry.Name.EndsWith(levelExt, StringComparison.OrdinalIgnoreCase) ||
entry.Name.EndsWith(packageExt, StringComparison.OrdinalIgnoreCase) ||
entry.Name.EndsWith(sceneExt, StringComparison.OrdinalIgnoreCase))
{
int slot = TrackValidator.GetSlot(entry.Name);
slot8 = slot == 8;
break;
}
}
}
if (slot8)
{
Console.WriteLine(string.Format("Slot 8 detected. Moving {0} to zip procesing folder.", Path.GetFileName(trackFileName)));
string fullFileName = string.Format("{0}/{1}", m_destinationFolder, Path.GetFileName(trackFileName));
if (File.Exists(fullFileName))
{
File.Delete(fullFileName);
}
File.Move(trackFileName, fullFileName);
}
}
}
public void FunctionHandler(SQSEvent sqsEvent, ILambdaContext context)
{
if (sqsEvent.Records.Count != 1)
{
throw new Exception(string.Format("Recived {0} records to process. Only 1 is supported.", sqsEvent.Records.Count));
}
var track = JsonConvert.DeserializeObject <Track>(sqsEvent.Records[0].Body);
if (track == null)
{
throw new Exception("There was an error parsing the lambda input");
}
TrackValidator validator = new TrackValidator();
MemoryStream zipStream = new MemoryStream();
ZipArchive zipArchive = new ZipArchive(zipStream, ZipArchiveMode.Create, true);
context.Logger.LogLine(string.Format("Beginning to process {0}", track.TrackName));
track = validator.ValidateTrack(track, (e) =>
{
var destFile = zipArchive.CreateEntry(e.Name);
using (var destStream = destFile.Open())
using (var srcStream = e.Open())
{
var task = srcStream.CopyToAsync(destStream);
task.Wait();
}
});
zipArchive.Dispose();
zipStream.Position = 0;
string folderName = track.TrackName;
string imageFileName = track.TrackName + ".jpg";
string trackFileName = track.TrackName + Path.GetExtension(track.SourceTrackUrl);
bool googleDrive = track.SourceTrackUrl.Contains("drive.google.com");
string bucketName = track.Valid ? "reflextracks" : "invalidreflextracks";
string baseDestUrl = string.Format("https://s3.amazonaws.com/{0}/{1}", bucketName, folderName).Replace(" ", "+");
track.TrackUrl = string.Format("{0}/{1}", baseDestUrl, trackFileName).Replace(" ", "+");
if (googleDrive)
{
track.TrackUrl = track.SourceTrackUrl;
}
track.ThumbnailUrl = string.Format("{0}/{1}", baseDestUrl, imageFileName).Replace(" ", "+");
using (WebClient client = new WebClient())
{
context.Logger.LogLine(string.Format("Attempting to load {0}", track.SourceThumbnailUrl));
using (Stream thumbNailStream = new MemoryStream(client.DownloadData(track.SourceThumbnailUrl)))
{
using (var jpegStream = new MemoryStream())
{
context.Logger.LogLine(string.Format("Ensuring {0} is a jpg file and resizing it to 640 x 360.", track.SourceThumbnailUrl));
MagickImage sourceImage = new MagickImage(thumbNailStream);
sourceImage.Resize(640, 360);
sourceImage.Write(jpegStream, MagickFormat.Jpg);
jpegStream.Position = 0;
context.Logger.LogLine(string.Format("Uploading {0} to s3.", track.ThumbnailUrl));
var uploadTask = AwsS3Utility.UploadFileAsync(jpegStream, string.Format("{0}/{1}", bucketName, folderName), imageFileName, RegionEndpoint.USEast1);
uploadTask.Wait();
}
}
if (track.Valid)
{
var uploadTask = AwsS3Utility.UploadFileAsync(zipStream, string.Format("{0}/{1}", bucketName, folderName), trackFileName, RegionEndpoint.USEast1);
uploadTask.Wait();
}
else if (googleDrive == false) //no support for downloading data directly from google drive
{
context.Logger.LogLine(string.Format("Attempting to copy {0} to invalid track bucket.", track.SourceTrackUrl));
using (Stream invalidStream = new MemoryStream(client.DownloadData(track.SourceTrackUrl)))
{
var uploadTask = AwsS3Utility.UploadFileAsync(invalidStream, string.Format("{0}/{1}", bucketName, folderName), trackFileName, RegionEndpoint.USEast1);
uploadTask.Wait();
}
}
}
track.FixEmptyStrings();
var dynamoContext = new DynamoDBContext(new AmazonDynamoDBClient(RegionEndpoint.USEast1));
dynamoContext.SaveAsync(track).Wait();
context.Logger.LogLine(string.Format("Processing {0} is complete!", track.TrackName));
}
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
var validator = new TrackValidator();
var result = validator.Validate(this);
return result.Errors.Select(item => new ValidationResult(item.ErrorMessage, new[] { item.PropertyName }));
}
public void FunctionHandler(SQSEvent sqsEvent, ILambdaContext context)
{
try
{
if (sqsEvent.Records.Count != 1)
{
throw new Exception(string.Format("Recived {0} records to process. Only 1 is supported.", sqsEvent.Records.Count));
}
var track = JsonConvert.DeserializeObject <Track>(sqsEvent.Records[0].Body);
if (track == null)
{
throw new Exception("There was an error parsing the lambda input");
}
TrackValidator validator = new TrackValidator();
MemoryStream zipStream = new MemoryStream();
ZipArchive zipArchive = new ZipArchive(zipStream, ZipArchiveMode.Create, true);
context.Logger.LogLine(string.Format("Beginning to process {0}", track.TrackName));
track = validator.ValidateTrack(track, (e) =>
{
var destFile = zipArchive.CreateEntry(e.Name);
using (var destStream = destFile.Open())
using (var srcStream = e.Open())
{
var task = srcStream.CopyToAsync(destStream);
task.Wait();
}
});
zipArchive.Dispose();
zipStream.Position = 0;
string folderName = Path.GetFileNameWithoutExtension(track.SourceTrackUrl.Replace("%20", " "));
string imageFileName = Path.GetFileName(track.SourceThumbnailUrl).Replace("%20", " ");
string trackFileName = Path.GetFileName(track.SourceTrackUrl).Replace("%20", " ");
string bucketName = track.Valid ? "reflextracks" : "invalidreflextracks";
string baseDestUrl = string.Format("https://s3.amazonaws.com/{0}/{1}", bucketName, folderName).Replace(" ", "+");
track.TrackUrl = string.Format("{0}/{1}", baseDestUrl, trackFileName).Replace(" ", "+");
track.ThumbnailUrl = string.Format("{0}/{1}", baseDestUrl, imageFileName).Replace(" ", "+");
using (WebClient client = new WebClient())
{
using (Stream thumbNailStream = new MemoryStream(client.DownloadData(track.SourceThumbnailUrl)))
{
var uploadTask = AwsS3Utility.UploadFileAsync(thumbNailStream, string.Format("{0}/{1}", bucketName, folderName), imageFileName, RegionEndpoint.USEast1);
uploadTask.Wait();
}
if (track.Valid)
{
var uploadTask = AwsS3Utility.UploadFileAsync(zipStream, string.Format("{0}/{1}", bucketName, folderName), trackFileName, RegionEndpoint.USEast1);
uploadTask.Wait();
}
else
{
using (Stream invalidStream = new MemoryStream(client.DownloadData(track.SourceTrackUrl)))
{
var uploadTask = AwsS3Utility.UploadFileAsync(invalidStream, string.Format("{0}/{1}", bucketName, folderName), trackFileName, RegionEndpoint.USEast1);
uploadTask.Wait();
}
}
}
track.FixEmptyStrings();
var success = HttpUtility.Post("https://spptqssmj8.execute-api.us-east-1.amazonaws.com/test/tracks", track);
context.Logger.LogLine(string.Format("Processing {0} is complete!", track.TrackName));
}
catch (Exception e)
{
context.Logger.LogLine(e.Message);
}
}
private void ProcessTrack(Track track, string zipFile)
{
//Reset to the defaults before re-processing the track
track.ErrorInfo = string.Empty;
track.TrackType = TrackType.Unknown;
track.Valid = true;
string thumbnailDownloadPath = track.SourceThumbnailUrl;
string folderName = track.TrackName;
string imageFileName = track.TrackName + Path.GetExtension(track.SourceThumbnailUrl);
string trackFileName = track.TrackName + ".zip"; // we know they are all zip files at this point.
track.ThumbnailUrl = string.Empty;
track.TrackUrl = string.Empty;
TrackValidator validator = new TrackValidator();
MemoryStream zipStream = new MemoryStream();
ZipArchive zipArchive = new ZipArchive(zipStream, ZipArchiveMode.Create, true);
Console.WriteLine(string.Format("Beginning to process {0}", track.TrackName));
track = validator.ValidateLocalTrack(zipFile, track, (e) =>
{
var destFile = zipArchive.CreateEntry(e.Name);
using (var destStream = destFile.Open())
using (var srcStream = e.Open())
{
var task = srcStream.CopyToAsync(destStream);
task.Wait();
}
});
zipArchive.Dispose();
zipStream.Position = 0;
string bucketName = track.Valid ? "reflextracks" : "invalidreflextracks";
string baseDestUrl = string.Format("https://s3.amazonaws.com/{0}/{1}", bucketName, folderName).Replace(" ", "+");
track.TrackUrl = string.Format("{0}/{1}", baseDestUrl, trackFileName).Replace(" ", "+");
track.ThumbnailUrl = string.Format("{0}/{1}", baseDestUrl, imageFileName).Replace(" ", "+");
using (WebClient webClient = new WebClient())
{
using (Stream thumbNailStream = new MemoryStream(webClient.DownloadData(thumbnailDownloadPath)))
{
Console.WriteLine(string.Format("Uploading {0} to s3 {1}...", imageFileName, bucketName));
var uploadTask = AwsS3Utility.UploadFileAsync(thumbNailStream, string.Format("{0}/{1}", bucketName, folderName), imageFileName, RegionEndpoint.USEast1);
uploadTask.Wait();
}
Console.WriteLine(string.Format("Uploading {0} to s3 {1}...", trackFileName, bucketName));
if (track.Valid)
{
var uploadTask = AwsS3Utility.UploadFileAsync(zipStream, string.Format("{0}/{1}", bucketName, folderName), trackFileName, RegionEndpoint.USEast1);
uploadTask.Wait();
}
else
{
using (var fileStream = new FileStream(zipFile, FileMode.Open))
{
var uploadTask = AwsS3Utility.UploadFileAsync(fileStream, string.Format("{0}/{1}", bucketName, folderName), trackFileName, RegionEndpoint.USEast1);
uploadTask.Wait();
}
}
}
track.FixEmptyStrings();
Console.WriteLine(string.Format("Updating {0} in dynamodb...", track.TrackName));
var client = new AmazonDynamoDBClient(RegionEndpoint.USEast1);
var context = new DynamoDBContext(client);
var saveTask = context.SaveAsync(track);
saveTask.Wait();
if (track.Valid)
{
Console.WriteLine("Deleting {0}", zipFile);
File.Delete(zipFile);
}
else
{
Console.WriteLine("[INVALID TRACK DATA] not deleting {0}, due to error ({1}). Please manually inspect..", zipFile, track.ErrorInfo);
}
Console.WriteLine(string.Format("Processing {0} is complete!", track.TrackName));
}
private Track[] SplitTracks(Track originalTrack, string fileName)
{
List <Track> newTracks = new List <Track>();
using (ZipArchive archive = ZipFile.OpenRead(fileName))
{
string databaseExt = ".dx9.database";
string levelExt = ".dx9.level";
string packageExt = ".dx9.package";
string sceneExt = ".dx9.scene";
Dictionary <string, List <ZipArchiveEntry> > trackBuckets = new Dictionary <string, List <ZipArchiveEntry> >();
foreach (ZipArchiveEntry entry in archive.Entries)
{
if (entry.Name.EndsWith(databaseExt, StringComparison.OrdinalIgnoreCase) ||
entry.Name.EndsWith(levelExt, StringComparison.OrdinalIgnoreCase) ||
entry.Name.EndsWith(packageExt, StringComparison.OrdinalIgnoreCase) ||
entry.Name.EndsWith(sceneExt, StringComparison.OrdinalIgnoreCase))
{
string type = TrackValidator.GetTrackType(entry.Name);
int slot = TrackValidator.GetSlot(entry.Name);
string key = string.Format("{0}:{1}", type, slot);
if (trackBuckets.ContainsKey(key) == false)
{
trackBuckets[key] = new List <ZipArchiveEntry>();
}
trackBuckets[key].Add(entry);
}
}
foreach (var bucket in trackBuckets)
{
const int trackFileCount = 4;
if (bucket.Value.Count == trackFileCount)
{
const int keyValueCount = 2;
var keyValues = bucket.Key.Split(":");
if (keyValues.Length == keyValueCount)
{
string trackName = string.Format("{0} ({1} S_{2})", originalTrack.TrackName, keyValues[0], keyValues[1]);
string path = string.Format(@"{0}\{1}.zip", m_destinationFolder, trackName);
Console.WriteLine("Creating new track ({0}) from {1}.", trackName, originalTrack.TrackName);
//Write track to file.
using (Stream zipStream = new FileStream(path, FileMode.Create))
{
using (ZipArchive zipArchive = new ZipArchive(zipStream, ZipArchiveMode.Create, true))
{
foreach (var entry in bucket.Value)
{
var destFile = zipArchive.CreateEntry(entry.Name);
using (var destStream = destFile.Open())
using (var srcStream = entry.Open())
{
var task = srcStream.CopyToAsync(destStream);
task.Wait();
}
}
}
}
var newTrack = new Track
{
TrackName = trackName,
SourceTrackUrl = originalTrack.SourceTrackUrl,
SourceThumbnailUrl = originalTrack.SourceThumbnailUrl,
TrackUrl = originalTrack.TrackUrl,
ThumbnailUrl = originalTrack.ThumbnailUrl,
Author = originalTrack.Author,
CreationTime = originalTrack.CreationTime
};
newTracks.Add(newTrack);
}
else
{
Console.Error.WriteLine(string.Format("Unexpected key values: {0}, for track {1}", bucket.Key, fileName));
}
}
else
{
Console.Error.WriteLine(string.Format("Unexpected track file counts in bucket {0}, for track {1}", bucket.Key, fileName));
}
}
}
return(newTracks.ToArray());
}
