public static HtmlProcessResult ProcessHtmlZip(string uploadPath, string zipFilePath, string orderNumber, bool isAddOptout, bool isAddViewinBrowser)
{
_orderNumber = orderNumber;
_isAddOptout = isAddOptout;
_isAddViewinBrowser = isAddViewinBrowser;
// Unzip
var directory = $"{uploadPath}\\{orderNumber}";
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
ZipFile.ExtractToDirectory(zipFilePath, directory);
// Change html
var imagesLive = string.Format("{0}/{0}img", orderNumber);
string htmlFileName = $"{orderNumber}.htm";
string htmlFileKey = string.Format("{0}/{0}.htm", orderNumber);
string htmlFilePath = $"{directory}\\{htmlFileName}";
string htmlFile = Directory.EnumerateFiles(directory).FirstOrDefault(x => x.EndsWith("htm") || x.EndsWith("html"));
if (string.IsNullOrEmpty(htmlFile))
{
throw new AdsException("Html not found");
}
UploadFileStatus status = ProcessHtml(htmlFile, htmlFilePath);
// Create 2501 directory
S3FileManager.CreateDirectory(orderNumber);
// Upload html
S3FileManager.Upload(htmlFileKey, htmlFilePath, true);
string filePathLive = $"{S3FileManager.ServerPrefix}{htmlFileKey}";
// Create images directory
S3FileManager.CreateDirectory(imagesLive);
// Upload Images
var images = Directory.EnumerateDirectories(directory).FirstOrDefault();
if (images != null)
{
foreach (var imgFile in Directory.EnumerateFiles(images))
{
var imageLive = $"{imagesLive}/{new FileInfo(imgFile).Name}";
S3FileManager.Upload(imageLive, imgFile, true);
}
}
// Delete tmp
new DirectoryInfo(directory).Delete(true);
return(new HtmlProcessResult()
{
Status = status, FilePathLive = filePathLive
});
}
public ActionResult DeleteFromList(string list, string email)
{
try
{
switch (list)
{
case "test":
string filePath = Path.Combine(UploadPath, (string)Session["TestSeedList"]);
new CreativeHelper().Remove(filePath, email);
S3FileManager.Upload((string)Session["TestSeedURL"], filePath, true);
break;
case "live":
string filePathLive = Path.Combine(UploadPath, (string)Session["FinalSeedList"]);
new CreativeHelper().Remove(filePathLive, email);
S3FileManager.Upload((string)Session["LiveSeedURL"], filePathLive, true);
break;
}
return(Json(new JsonResponse()
{
IsSucess = true
}));
}
catch (Exception ex)
{
return(Json(new JsonResponse()
{
IsSucess = false, ErrorMessage = ex.Message
}));
}
}
public static void PopulateFakeData(WfpictContext db, Campaign campaign, string orderNumber, string UploadPath)
{
// Process Links file
string filePath = Path.Combine(UploadPath, campaign.Assets.OpenModelLinksFile);
S3FileManager.Download(campaign.Assets.OpenModelLinksFile, filePath);
List <string> links = CsvReader.ReadCsv(filePath);
PopulateFakeData(db, campaign, orderNumber, links);
}
// Creative
public ActionResult Index(Guid id)
{
var campaign = Db.Campaigns
.Include(c => c.Assets)
.Include(c => c.Testing)
.Include(c => c.Approved)
.Include(c => c.Creative)
.FirstOrDefault(c => c.Id == id);
Session["id"] = id;
Session["OrderNumber"] = campaign.OrderNumber;
var creative = new CreativeVm()
{
CampaignId = campaign.Id.ToString(),
OrderNumber = campaign.OrderNumber,
CampaignName = campaign.Testing.CampaignName,
FromLine = campaign.Testing.FromLine,
SubjectLine = campaign.Testing.SubjectLine,
TestSeedFile = campaign.Assets.TestSeedFile,
LiveSeedFile = campaign.Assets.LiveSeedFile,
Creatives = campaign.Creative?.CreativeHtml,
TestEmails = new List <SelectItemPair>(),
LiveEmails = new List <SelectItemPair>()
};
if (!string.IsNullOrEmpty(campaign.Assets.TestSeedFile))
{
string filePath = Path.Combine(UploadPath, campaign.Assets.TestSeedFile);
if (!System.IO.File.Exists(filePath) && !string.IsNullOrEmpty(campaign.Assets.TestSeedFile))
{
S3FileManager.Download(campaign.Assets.TestSeedFile, filePath);
}
creative.TestEmails = CreativeHelper.ReadEmails(filePath);
}
if (!string.IsNullOrEmpty(campaign.Assets.LiveSeedFile))
{
string filePathLive = Path.Combine(UploadPath, campaign.Assets.LiveSeedFile);
if (!System.IO.File.Exists(filePathLive) && !string.IsNullOrEmpty(campaign.Assets.LiveSeedFile))
{
S3FileManager.Download(campaign.Assets.LiveSeedFile, filePathLive);
}
creative.LiveEmails = CreativeHelper.ReadEmails(filePathLive);
}
Session["TestSeedFile"] = campaign.Assets.TestSeedFile;
Session["TestSeedUrl"] = campaign.Assets.TestSeedUrl;
Session["LiveSeedFile"] = campaign.Assets.LiveSeedFile;
Session["LiveSeedUrl"] = campaign.Assets.LiveSeedUrl;
return(View(creative));
}
public ActionResult DownloadFile(UploadFileVm fileVm)
{
string filePath = Path.Combine(UploadPath, fileVm.FileName);
if (fileVm.FileType == "CompanyLogo")
{
filePath = Path.Combine(ImagesPath, fileVm.FileName);
}
else if (IsUseS3)
{
S3FileManager.Download(fileVm.FileName, filePath);
}
return(File(filePath, "text/csv", fileVm.FileName));
}
private static void WriteAndUploadSegmentDataFile(List <SegmentResponse> data, WfpictContext db, CampaignSegment segment, string uploadPath, string orderNumber, Guid campaignId)
{
string fileName1 = $"{orderNumber}\\{segment.SegmentNumber}data.csv";
var filePath1 = $"{uploadPath}\\{fileName1}";
var data1 =
data.Where(x => x.Index >= segment.FirstRangeStart && x.Index <= segment.FirstRangeEnd).ToList();
var data2 =
data.Where(x => x.Index >= segment.SecondRangeStart && x.Index <= segment.SecondRangeEnd)
.ToList();
var data3 =
data.Where(x => x.Index >= segment.ThirdRangeStart && x.Index <= segment.ThirdRangeEnd).ToList();
data2.AddRange(data3);
data1.AddRange(data2);
data1 = data1.OrderBy(x => x.Index).ToList();
data1.ToCsv(filePath1, new CsvDefinition()
{
EndOfLine = "\r\n",
FieldSeparator = ',',
TextQualifier = '"',
Columns =
new List <string>
{
"SalesMasterId",
"FirstName",
"LastName",
"Address",
"City",
"State",
"Zip",
"Zip4",
"Apt",
"Dealership_ID",
"Index",
}
});
string amazonFileKey1 = $"{orderNumber}/{segment.SegmentNumber}data.csv";
S3FileManager.Upload(amazonFileKey1, filePath1, true);
segment.SegmentDataFileUrl = FileManager.GetFilePathLive(UploadFileType.DataFile,
orderNumber, string.Empty, segment.SegmentNumber);
segment.DateFetched = DateTime.Now;
segment.UploadStatus = (int)UploadFileStatus.Completed;
segment.SegmentStatus = (int)SegmentStatus.Generated;
LogHelper.AddLog(db, LogType.DataProcessing, orderNumber,
fileName1 + " data file generated and uploaded to Amazon sucessfully.");
}
public static ClickMeterLink ProcessLinksFile(string uploadPath, string orderNumber, string campaignName, string ezLinksFile)
{
string linkName = $"{orderNumber}links";
var linksWeights = new List <DestinationItem>();
try
{
string ezLinksFilePath = Path.Combine(uploadPath, ezLinksFile);
S3FileManager.Download(ezLinksFile, ezLinksFilePath);
foreach (var line in System.IO.File.ReadAllLines(ezLinksFilePath))
{
if (string.IsNullOrEmpty(line))
{
continue;
}
var links = line.Split(",".ToCharArray());
if (links.Length != 2)
{
continue;
}
int w8 = 0;
int.TryParse(links[1], out w8);
var lw = new DestinationItem()
{
url = links[0], weight = w8
};
linksWeights.Add(lw);
}
}
catch (Exception ex)
{
throw new AdsException("There is some issue in processing links file.");
}
int sum = linksWeights.Sum(x => x.weight);
if (sum != 100)
{
throw new AdsException("Click Meter Links wieght must sum upto 100. (" + sum + ")");
}
return(CreateCampaignWithRotatorLink(orderNumber, campaignName, linkName, linksWeights.ToArray()));
}
private static List <string> ProcessZipFile(WfpictContext db, string uploadPath, string zipCodeFile, string orderNumber)
{
string zipFilePath = Path.Combine(uploadPath, zipCodeFile);
S3FileManager.Download(zipCodeFile, zipFilePath);
var list = new List <string>();
foreach (var line in File.ReadAllLines(zipFilePath))
{
var trimmed = StringHelper.Trim(line);
if (string.IsNullOrEmpty(trimmed))
{
continue;
}
list.Add(trimmed);
}
LogHelper.AddLog(db, LogType.DataProcessing, orderNumber, $"ZipCodeFile {zipCodeFile} processed sucessfully.");
return(list);
}
public static List <DynamicCodingInput> LoadLookupInput(string uploadPath, string dynamicCodingFile)
{
List <DynamicCodingInput> inputs = new List <DynamicCodingInput>();
string dyanmicFilePath = System.IO.Path.Combine(uploadPath, dynamicCodingFile);
S3FileManager.Download(dynamicCodingFile, dyanmicFilePath);
try
{
bool isFirstHeader = true;
foreach (var line in System.IO.File.ReadAllLines(dyanmicFilePath))
{
if (isFirstHeader)
{
isFirstHeader = false; continue;
}
if (string.IsNullOrEmpty(line))
{
continue;
}
string[] trimmedCells = line.Split(",".ToCharArray());
if (trimmedCells.Length != 3 || NumberHelper.Parse(trimmedCells[2]) == -1)
{
continue;
}
inputs.Add(new DynamicCodingInput()
{
OrignalURL = trimmedCells[0],
URLType = trimmedCells[1],
Qunatity = Int32.Parse(trimmedCells[2])
});
}
return(inputs);
}
catch (Exception ex)
{
throw new AdsException("There is something wrong with Dynamic Coding File. Please upload correct one." + ex.Message);
}
}
private static void WriteAndUploadDataFile(List <SegmentResponse> data, WfpictContext db, string uploadPath,
string orderNumber, Guid campaignId)
{
string fileName = $"{orderNumber}\\{orderNumber}data.csv";
var filePath = $"{uploadPath}\\{fileName}";
data.Sort((x, y) => x.Index.CompareTo(y.Index));
data.ToCsv(filePath, new CsvDefinition()
{
EndOfLine = "\r\n",
FieldSeparator = ',',
TextQualifier = '"',
Columns =
new List <string>
{
"SalesMasterId",
"FirstName",
"LastName",
"Address",
"City",
"State",
"Zip",
"Zip4",
"Apt",
"Dealership_ID",
"Index",
}
});
string amazonFileKey = $"{orderNumber}/{orderNumber}data.csv";
S3FileManager.Upload(amazonFileKey, filePath, true);
LogHelper.AddLog(db, LogType.DataProcessing, orderNumber, $"{fileName} data file generated and uploaded to Amazon sucessfully.");
var campaignTesting = db.CampaignsTesting.FirstOrDefault(x => x.CampaignId == campaignId);
if (campaignTesting != null)
{
campaignTesting.DataFileUrl = amazonFileKey;
campaignTesting.DateFetched = DateTime.Now;
}
db.SaveChanges();
}
public static List <SelectListItem> GetZipCodes(string uploadPath, string zipCodeFile)
{
string zipFilePath = Path.Combine(uploadPath, zipCodeFile);
S3FileManager.Download(zipCodeFile, zipFilePath);
var zipCodes = new List <SelectListItem>();
foreach (var line in System.IO.File.ReadAllLines(zipFilePath))
{
var trimmed = StringHelper.Trim(line);
if (string.IsNullOrEmpty(trimmed))
{
continue;
}
zipCodes.Add(new SelectListItem()
{
Text = trimmed, Value = trimmed
});
}
return(zipCodes);
}
private static void WriteAndUploadDataFileOpener(List <SegmentResponse> data, WfpictContext db, string uploadPath, string orderNumber, Guid campaignId)
{
string fileName = $"{orderNumber}\\{orderNumber}opener.csv";
var filePath = $"{uploadPath}\\{fileName}";
data.ToCsv(filePath, new CsvDefinition()
{
EndOfLine = "\r\n",
FieldSeparator = ',',
TextQualifier = '"',
Columns =
new List <string>
{
"SalesMasterId",
"FirstName",
"LastName",
"Address",
"City",
"State",
"Zip",
"Zip4",
"Apt"
}
});
string amazonFileKey = $"{orderNumber}/{orderNumber}opener.csv";
S3FileManager.Upload(amazonFileKey, filePath, true);
var campaignTesting = db.CampaignsTesting.FirstOrDefault(x => x.CampaignId == campaignId);
if (campaignTesting != null)
{
campaignTesting.DataFileUrlOpener = FileManager.GetFilePathLive(UploadFileType.DataFileOpener,
orderNumber, string.Empty, string.Empty);
}
db.SaveChanges();
LogHelper.AddLog(db, LogType.DataProcessing, orderNumber,
fileName + " data file opener generated and uploaded to Amazon sucessfully.");
}
public JsonResult DeleteFile(UploadFileVm fileVm)
{
try
{
if (IsUseS3)
{
S3FileManager.Delete(fileVm.FileName);
}
else if (!IsUseS3)
{
string filePath = Path.Combine(UploadPath, fileVm.FileName);
if (System.IO.File.Exists(filePath))
{
System.IO.File.Delete(filePath);
}
}
if (fileVm.FileType == "CompanyLogo")
{
string filePath = Path.Combine(ImagesPath, fileVm.FileName);
if (System.IO.File.Exists(filePath))
{
System.IO.File.Delete(filePath);
}
}
return(Json(new JsonResponse()
{
IsSucess = true
}));
}
catch (Exception ex)
{
return(Json(new JsonResponse()
{
IsSucess = false, ErrorMessage = "File Delete failed. " + ex.Message
}));
}
}
public ActionResult SaveInput(OpenModelInputVm vm)
{
if (ModelState.IsValid)
{
Campaign campaign = Db.Campaigns
.Include(x => x.Assets)
.FirstOrDefault(x => x.Id.ToString() == vm.Id);
campaign.Assets.OpenModelLinksFile = vm.OpenModelLinksFile;
campaign.Assets.OpenModelImageFile = vm.OpenModelImageFile;
if (!string.IsNullOrEmpty(vm.SFDClientId))
{
campaign.Assets.SFDClientId = int.Parse(vm.SFDClientId);
}
if (!string.IsNullOrEmpty(campaign.Assets.OpenModelLinksFile))
{
string filePath = Path.Combine(UploadPath, campaign.Assets.OpenModelLinksFile);
S3FileManager.Download(campaign.Assets.OpenModelLinksFile, filePath);
List <string> links = CsvReader.ReadCsv(filePath);
campaign.Assets.OpenModelLinksCount = links.Count;
}
Db.SaveChanges();
TempData["Success"] = "Reporting Model Input data saved successfully!";
return(RedirectToAction("View", "OpenModel", new { id = vm.Id }));
}
else
{
var errorList = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
TempData["Error"] = "There is error in saving data." + string.Join("<br/>", errorList);
}
return(View("OpenModelInput", vm));
}
public static void ProcessInput(WfpictContext db, string uploadPath, string dataFileUrl, string dynamicCodingFile, Guid?campaignId, string orderNumber)
{
List <DynamicCodingInput> inputs;
try
{
inputs = LoadLookupInput(uploadPath, dynamicCodingFile);
}
catch (Exception ex)
{
throw new AdsException("There is something wrong with Dynamic Coding File. Please upload correct one." + ex.Message);
}
int TotalQuantityRequired = inputs.Sum(x => x.Qunatity);
// Process Data file
string dataFilePath = Path.Combine(uploadPath, dataFileUrl);
S3FileManager.Download(dataFileUrl, dataFilePath);
List <string> salesIds = GetRandomSalesIds(dataFilePath, TotalQuantityRequired);
if (salesIds.Count < TotalQuantityRequired)
{
throw new AdsException("Sales Ids are less than required in the Dynamic links file. Please increase data file Quntity.");
}
// Add Lookups
db.DynamicCodingLookups.RemoveRange(db.DynamicCodingLookups.Where(x => x.CampaignId == campaignId));
db.SaveChanges();
int Index = 1;
foreach (var input in inputs)
{
db.DynamicCodingLookups.Add(new DynamicCodingLookup()
{
Id = Guid.NewGuid(),
CreatedAt = DateTime.Now,
CampaignId = campaignId,
OrderNumber = orderNumber,
OrignalURL = input.OrignalURL,
URLType = input.URLType,
Qunatity = input.Qunatity,
VerumURL = $"{orderNumber}/{input.URLType}/{Index}"
});
Index++;
}
db.SaveChanges();
// Add Links
db.DynamicCodingLinks.RemoveRange(db.DynamicCodingLinks.Where(x => x.CampaignId == campaignId));
db.SaveChanges();
int Index2 = 0;
foreach (var lookUp in db.DynamicCodingLookups.Where(x => x.CampaignId == campaignId))
{
for (int quantity = 0; quantity < lookUp.Qunatity; quantity++)
{
int salesId = Int32.Parse(salesIds[Index2]);
db.DynamicCodingLinks.Add(new DynamicCodingLink()
{
Id = Guid.NewGuid(),
CreatedAt = DateTime.Now,
CampaignId = campaignId,
OrderNumber = orderNumber,
SalesMasterId = salesId,
URLType = lookUp.URLType,
OrignalURL = lookUp.OrignalURL.Replace("{{unique}}", salesId.ToString()),
VerumURL = lookUp.VerumURL,
IsURLRedemed = false
});
Index2++;
}
}
db.SaveChanges();
}
public ReportGenerationResultVm GenerateReport(Guid?id, Guid?trackingId, string template, string format)
{
Campaign campaign = Db.Campaigns
.Include(x => x.Assets)
.Include(x => x.Segments)
.Include(x => x.ProDatas)
.Include(x => x.Testing)
.Include(x => x.Approved)
.Include(x => x.Trackings)
.FirstOrDefault(x => x.Id == id);
if (campaign == null)
{
throw new AdsException("Campaign not found.");
}
if (campaign.Approved == null)
{
throw new AdsException("Campaign is not passed through Testing and Approved phase.");
}
var campaignTracking = campaign.Trackings.FirstOrDefault(x => x.Id == trackingId);
if (campaignTracking == null)
{
throw new AdsException("No Tracking data available.");
}
var whiteLable = Db.Customers.FirstOrDefault(x => x.WhiteLabel == campaign.Approved.WhiteLabel);
if (whiteLable == null)
{
throw new AdsException("Campaign White Label not set in approved screen.");
}
var reportTemplate = !string.IsNullOrEmpty(template) ? template : whiteLable.ReportTemplate;
// Creative HTML screenshot
string creativeUrl = campaign.Assets.CreativeUrl,
screenshotFilePathTemp = $"{UploadPath}\\{campaign.OrderNumber}t.png",
screenshotFilePath = $"{UploadPath}\\{campaign.OrderNumber}.png";
if (whiteLable.IsUseOpenModel && !string.IsNullOrEmpty(campaign.Assets.OpenModelImageFile))
{
S3FileManager.Download(campaign.Assets.OpenModelImageFile, screenshotFilePathTemp);
}
else
{
var helper = new ImageHelper(creativeUrl, screenshotFilePathTemp);
if (!System.IO.File.Exists(screenshotFilePath))
{
helper.Capture();
}
}
int ScreenshotHeight = "Tracking1".Equals(reportTemplate) || "Tracking2".Equals(reportTemplate) || "TrackingReTargeting".Equals(reportTemplate) ? 750 : 500;
if (System.IO.File.Exists(screenshotFilePathTemp))
{
ImageResizer.Resize(screenshotFilePathTemp, screenshotFilePath, 400, ScreenshotHeight, true);
System.IO.File.Delete(screenshotFilePathTemp);
}
string contentType = "", outputFileName = "", outputFilePath = "";
switch (format)
{
//case "pdf":
// var modelView = CampaignTrackingVm.FromCampaignTracking(campaign, campaignTracking);
// outputFileName = $"{campaign.OrderNumber} {whiteLable?.WhiteLabel}.pdf";
// outputFilePath = Path.Combine(DownloadPath, outputFileName);
// contentType = "application/pdf";
// // Generate pdf
// new TemplateReportPdf().Generate(modelView, outputFilePath, whiteLable.CompanyLogo, screenshotFilePath);
// break;
// case "excel":
default:
var modelReport = TemplateReportVm.FromCampaignTracking(campaign, campaignTracking);
outputFileName = $"{campaign.OrderNumber}.xlsx";
outputFilePath = Path.Combine(DownloadPath, outputFileName);
contentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
BaseTrackingReport report = null;
switch (reportTemplate)
{
case "Tracking1":
case "Tracking2":
case "TrackingReTargeting":
report = new TrackingReportTemplate12(reportTemplate, campaign.Approved.WhiteLabel, whiteLable.CompanyLogo, screenshotFilePath);
break;
case "Tracking3":
case "Tracking4":
report = new TrackingReportTemplate34(reportTemplate, campaign.Approved.WhiteLabel, whiteLable.CompanyLogo, screenshotFilePath);
break;
case "TrackingStrat":
report = new TrackingReportTemplateStrat(reportTemplate, campaign.Approved.WhiteLabel, whiteLable.CompanyLogo, screenshotFilePath);
break;
default:
report = new TrackingReportTemplate12(reportTemplate, campaign.Approved.WhiteLabel, whiteLable.CompanyLogo, screenshotFilePath);
break;
}
report.Generate(modelReport, outputFilePath);
break;
}
if ("pdf".Equals(format))
{
string outputFileNamePdf = $"{campaign.OrderNumber} {whiteLable?.WhiteLabel}t.pdf";
string outputFilePathPdf = Path.Combine(DownloadPath, outputFileNamePdf);
string outputFileNamePdfFinal = $"{campaign.OrderNumber} {whiteLable?.WhiteLabel}.pdf";
string outputFilePathPdfFinal = Path.Combine(DownloadPath, outputFileNamePdfFinal);
contentType = "application/pdf";
Infrastructure.Pdf.Introp.Generate(outputFilePath, outputFilePathPdf);
string pageSelection = ("Tracking1".Equals(reportTemplate) || "Tracking2".Equals(reportTemplate) ||
"TrackingReTargeting".Equals(reportTemplate) || "Tracking3".Equals(reportTemplate) ? "1-2" :
"Tracking4".Equals(reportTemplate) || "TrackingStrat".Equals(reportTemplate) ? "1-3" : "1");
Infrastructure.Pdf.PdfOrganizer.SelectPages(outputFilePathPdf, pageSelection, outputFilePathPdfFinal);
System.IO.File.Delete(outputFilePathPdf);
outputFileName = outputFileNamePdfFinal;
outputFilePath = outputFilePathPdfFinal;
}
return(new ReportGenerationResultVm()
{
orderNumber = campaign.OrderNumber,
contentType = contentType,
outputFileName = outputFileName,
outputFilePath = outputFilePath
});
}
public static void ProcessNewOrderFiles(WfpictContext db, Campaign campaign)
{
if (!string.IsNullOrEmpty(campaign.Assets.CreativeFiles))
{
string amazonFileKey = string.Format("{0}/{0}_html.zip", campaign.OrderNumber);
S3FileManager.Move(campaign.Assets.CreativeFiles, amazonFileKey, campaign.OrderNumber, true);
campaign.Assets.CreativeFiles = amazonFileKey;
LogHelper.AddLog(db, LogType.FileProcessing, campaign.OrderNumber,
"CreativeFiles moved to " + amazonFileKey);
}
if (!string.IsNullOrEmpty(campaign.Assets.ZipCodeFile))
{
string amazonFileKey = string.Format("{0}/{0}zip.csv", campaign.OrderNumber);
S3FileManager.Move(campaign.Assets.ZipCodeFile, amazonFileKey, campaign.OrderNumber, true);
campaign.Assets.ZipCodeFile = amazonFileKey;
LogHelper.AddLog(db, LogType.FileProcessing, campaign.OrderNumber,
"ZipCodeFile moved to " + amazonFileKey);
}
if (!string.IsNullOrEmpty(campaign.Assets.TestSeedFile))
{
string amazonFileKey = string.Format("{0}/{0}test.csv", campaign.OrderNumber);
S3FileManager.Move(campaign.Assets.TestSeedFile, amazonFileKey, campaign.OrderNumber, true);
campaign.Assets.TestSeedFile = amazonFileKey;
LogHelper.AddLog(db, LogType.FileProcessing, campaign.OrderNumber,
"TestSeedFile moved to " + amazonFileKey);
}
if (!string.IsNullOrEmpty(campaign.Assets.LiveSeedFile))
{
string amazonFileKey = string.Format("{0}/{0}live.csv", campaign.OrderNumber);
S3FileManager.Move(campaign.Assets.LiveSeedFile, amazonFileKey, campaign.OrderNumber, true);
campaign.Assets.LiveSeedFile = amazonFileKey;
LogHelper.AddLog(db, LogType.FileProcessing, campaign.OrderNumber,
"LiveSeedFile moved to " + amazonFileKey);
}
if (!string.IsNullOrEmpty(campaign.Assets.SuppressionFile))
{
string amazonFileKey = string.Format("{0}/{0}supp.csv", campaign.OrderNumber);
S3FileManager.Move(campaign.Assets.SuppressionFile, amazonFileKey, campaign.OrderNumber, true);
campaign.Assets.SuppressionFile = amazonFileKey;
LogHelper.AddLog(db, LogType.FileProcessing, campaign.OrderNumber,
"SuppressionFile moved to " + amazonFileKey);
}
if (!string.IsNullOrEmpty(campaign.Assets.BannersFile))
{
string amazonFileKey = string.Format("{0}/{0}_banner{1}", campaign.OrderNumber,
Path.GetExtension(campaign.Assets.BannersFile));
S3FileManager.Move(campaign.Assets.BannersFile, amazonFileKey, campaign.OrderNumber, true);
campaign.Assets.BannersFile = amazonFileKey;
LogHelper.AddLog(db, LogType.FileProcessing, campaign.OrderNumber,
"BannersFile moved to " + amazonFileKey);
}
if (!string.IsNullOrEmpty(campaign.Assets.BannerLinksFile))
{
string amazonFileKey = string.Format("{0}/{0}_bannerlinks{1}", campaign.OrderNumber,
Path.GetExtension(campaign.Assets.BannerLinksFile));
S3FileManager.Move(campaign.Assets.BannerLinksFile, amazonFileKey, campaign.OrderNumber, true);
campaign.Assets.BannerLinksFile = amazonFileKey;
LogHelper.AddLog(db, LogType.FileProcessing, campaign.OrderNumber,
"BannerLinksFile moved to " + amazonFileKey);
}
if (!string.IsNullOrEmpty(campaign.Assets.MiscFile))
{
string amazonFileKey = string.Format("{0}/{0}_misc{1}", campaign.OrderNumber,
Path.GetExtension(campaign.Assets.MiscFile));
S3FileManager.Move(campaign.Assets.MiscFile, amazonFileKey, campaign.OrderNumber, true);
campaign.Assets.MiscFile = amazonFileKey;
LogHelper.AddLog(db, LogType.FileProcessing, campaign.OrderNumber, "MiscFile moved to " + amazonFileKey);
}
foreach (var segment in campaign.Segments)
{
if (string.IsNullOrEmpty(segment.CreativeFiles))
{
continue;
}
string amazonFileKey = $"{campaign.OrderNumber}/{segment.SegmentNumber}_html.zip";
S3FileManager.Move(segment.CreativeFiles, amazonFileKey, campaign.OrderNumber, true);
segment.CreativeFiles = amazonFileKey;
LogHelper.AddLog(db, LogType.FileProcessing, campaign.OrderNumber,
"Segment " + segment.SegmentNumber + " CreativeFiles moved to " + amazonFileKey);
}
}
public static void ProcessAssetUpdateUrls(string uploadPath, string orderNumber)
{
using (var db = new WfpictContext())
{
var campaign = db.Campaigns.Include(x => x.Assets).FirstOrDefault(x => x.OrderNumber == orderNumber);
var directory = $"{uploadPath}\\{campaign.OrderNumber}";
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
// HtmlImagesURL
try
{
if (!string.IsNullOrEmpty(campaign.Assets.CreativeFiles))
{
string filePath = Path.Combine(uploadPath, campaign.Assets.CreativeFiles);
S3FileManager.Download(campaign.Assets.CreativeFiles, filePath);
var result = FileManager.ProcessHtmlZip(uploadPath, filePath, campaign.OrderNumber, campaign.IsAddOptOut, campaign.IsAddViewInBrowser);
campaign.Assets.CreativeUrl = result.FilePathLive;
campaign.Assets.CreativeStatus = (int)result.Status;
LogHelper.AddLog(db, LogType.FileProcessing, orderNumber, "CreativeFiles processed: " + campaign.Assets.CreativeUrl + ", Status: " + System.Enum.GetName(typeof(UploadFileStatus), campaign.Assets.CreativeStatus));
}
}
catch (Exception ex)
{
campaign.Assets.CreativeStatus = (int)UploadFileStatus.Failed;
LogHelper.AddError(db, LogType.FileProcessing, orderNumber, "CreativeFiles processing failed, " + ex.Message + ", Status: " + System.Enum.GetName(typeof(UploadFileStatus), campaign.Assets.CreativeStatus));
}
db.SaveChanges();
if (!string.IsNullOrEmpty(campaign.Assets.ZipCodeFile))
{
campaign.Assets.ZipCodeUrl = FileManager.GetFilePathLive(UploadFileType.ZipFile,
campaign.OrderNumber);
campaign.Assets.ZipCodeStatus = (int)UploadFileStatus.Completed;
LogHelper.AddLog(db, LogType.FileProcessing, orderNumber,
"ZipCodeFile processed: " + campaign.Assets.ZipCodeUrl + ", Status: " +
System.Enum.GetName(typeof(UploadFileStatus), campaign.Assets.ZipCodeStatus));
}
// TestSeedList
if (!string.IsNullOrEmpty(campaign.Assets.TestSeedFile))
{
campaign.Assets.TestSeedUrl = FileManager.GetFilePathLive(UploadFileType.TestSeedFile,
campaign.OrderNumber);
campaign.Assets.TestSeedStatus = (int)UploadFileStatus.Completed;
LogHelper.AddLog(db, LogType.FileProcessing, orderNumber,
"TestSeedFile processed: " + campaign.Assets.TestSeedUrl + ", Status: " +
System.Enum.GetName(typeof(UploadFileStatus), campaign.Assets.TestSeedStatus));
}
// Final SeedList
if (!string.IsNullOrEmpty(campaign.Assets.LiveSeedFile))
{
campaign.Assets.LiveSeedUrl = FileManager.GetFilePathLive(UploadFileType.LiveSeedFile,
campaign.OrderNumber);
campaign.Assets.LiveSeedStatus = (int)UploadFileStatus.Completed;
LogHelper.AddLog(db, LogType.FileProcessing, orderNumber,
"LiveSeedFile processed: " + campaign.Assets.LiveSeedUrl + ", Status: " +
System.Enum.GetName(typeof(UploadFileStatus), campaign.Assets.LiveSeedStatus));
}
// Suppression
if (!string.IsNullOrEmpty(campaign.Assets.SuppressionFile))
{
campaign.Assets.SuppressionUrl = FileManager.GetFilePathLive(UploadFileType.SuppressionFile,
campaign.OrderNumber);
campaign.Assets.SuppressionStatus = (int)UploadFileStatus.Completed;
LogHelper.AddLog(db, LogType.FileProcessing, orderNumber,
"SuppressionFile processed: " + campaign.Assets.SuppressionUrl + ", Status: " +
System.Enum.GetName(typeof(UploadFileStatus), campaign.Assets.SuppressionStatus));
}
db.SaveChanges();
// Banner
if (!string.IsNullOrEmpty(campaign.Assets.BannersFile))
{
campaign.Assets.BannersUrl = FileManager.GetFilePathLive(UploadFileType.BannersFile,
campaign.OrderNumber, Path.GetExtension(campaign.Assets.BannersFile));
campaign.Assets.BannersStatus = (int)UploadFileStatus.Completed;
LogHelper.AddLog(db, LogType.FileProcessing, orderNumber,
"BannersFile processed: " + campaign.Assets.BannersUrl + ", Status: " +
System.Enum.GetName(typeof(UploadFileStatus), campaign.Assets.BannersStatus));
}
// Banner Links
if (!string.IsNullOrEmpty(campaign.Assets.BannerLinksFile))
{
campaign.Assets.BannerLinksUrl = FileManager.GetFilePathLive(UploadFileType.BannersLinksFile,
campaign.OrderNumber, Path.GetExtension(campaign.Assets.BannerLinksFile));
campaign.Assets.BannerLinksStatus = (int)UploadFileStatus.Completed;
LogHelper.AddLog(db, LogType.FileProcessing, orderNumber,
"BannerLinksFile processed: " + campaign.Assets.BannerLinksUrl + ", Status: " +
System.Enum.GetName(typeof(UploadFileStatus), campaign.Assets.BannerLinksStatus));
}
// Misc
if (!string.IsNullOrEmpty(campaign.Assets.MiscFile))
{
campaign.Assets.MiscUrl = FileManager.GetFilePathLive(UploadFileType.MiscFile,
campaign.OrderNumber, Path.GetExtension(campaign.Assets.MiscFile));
campaign.Assets.MiscStatus = (int)UploadFileStatus.Completed;
LogHelper.AddLog(db, LogType.FileProcessing, orderNumber,
"MiscFile processed: " + campaign.Assets.MiscUrl + ", Status: " +
System.Enum.GetName(typeof(UploadFileStatus), campaign.Assets.MiscStatus));
}
}
}
public ActionResult EditTesting([Bind(Include =
"Assets,Segments,Id,CampaignId,OrderNumber,CampaignName,WhiteLabel,ReBroadCast,ReBroadcastDate,FromLine,SubjectLine,HtmlImageFiles,CreativeURL,TestSeedList,FinalSeedList,IsTested,TestingTime,TestingUrgency,DeployDate,ZipCodeFile,ZipURL,GeoDetails,Demographics,Quantity,SpecialInstructions,CreatedAt,CreatedBy,IsOpenPixel,OpenPixelUrl,BannerUrl,OpenGoals,ClickGoals,DataFileQuantity,DataFileUrl,DateFetched,IsOmniOrder,OmniDeployDate,Impressions,ChannelTypes,PaceDays,IsDynamicCoding,DynamicCodingFile,OpenModelLinksFile,OpenModelLinksCount,OpenModelImageFile,SFDClientId,ClickMeterGroupId,ClickMeterRotatorLinkId,ClickMeterRotatorLink,EzStates,EzDMAs,EzLinksFile"
)] CampaignTestingVm campaignTestingVm)
{
if (ModelState.IsValid)
{
// Updatin Testing
TinyMapper.Bind <CampaignTestingVm, CampaignTesting>(config =>
{
config.Ignore(x => x.ChannelTypes);
config.Ignore(x => x.Assets);
config.Ignore(x => x.Segments);
});
var campaignTesting = TinyMapper.Map <CampaignTesting>(campaignTestingVm);
campaignTesting.ChannelTypes = campaignTestingVm.ChannelTypes == null ? null :
string.Join(",", campaignTestingVm.ChannelTypes);
Db.Entry(campaignTesting).State = EntityState.Modified;
Db.SaveChanges();
// Updatin Asssets
var campaignAssets = Db.CampaignAssets.FirstOrDefault(x => x.CampaignId == campaignTestingVm.CampaignId);
campaignAssets.CreativeFiles = campaignTestingVm.Assets.CreativeFiles;
campaignAssets.CreativeUrl = campaignTestingVm.Assets.CreativeUrl;
campaignAssets.ZipCodeFile = campaignTestingVm.Assets.ZipCodeFile;
campaignAssets.ZipCodeUrl = campaignTestingVm.Assets.ZipCodeUrl;
campaignAssets.TestSeedFile = campaignTestingVm.Assets.TestSeedFile;
campaignAssets.LiveSeedFile = campaignTestingVm.Assets.LiveSeedFile;
campaignAssets.OpenModelLinksFile = campaignTestingVm.OpenModelLinksFile;
campaignAssets.OpenModelImageFile = campaignTestingVm.OpenModelImageFile;
if (!string.IsNullOrEmpty(campaignTestingVm.SFDClientId))
{
campaignAssets.SFDClientId = int.Parse(campaignTestingVm.SFDClientId);
}
if (!string.IsNullOrEmpty(campaignAssets.OpenModelLinksFile) && campaignAssets.OpenModelLinksCount == 0)
{
string filePath = Path.Combine(UploadPath, campaignAssets.OpenModelLinksFile);
S3FileManager.Download(campaignAssets.OpenModelLinksFile, filePath);
List <string> links = CsvReader.ReadCsv(filePath);
campaignAssets.OpenModelLinksCount = links.Count;
}
Db.Entry(campaignAssets).State = EntityState.Modified;
Db.SaveChanges();
// Updating Segments
if (campaignTestingVm.Segments != null)
{
foreach (var segmentVm in campaignTestingVm.Segments)
{
var segment = Db.CampaignSegments.FirstOrDefault(x => x.Id == segmentVm.Id);
if (segment == null)
{
segment = new CampaignSegment()
{
Id = Guid.NewGuid(),
CreatedAt = DateTime.Now,
CampaignId = campaignTestingVm.CampaignId,
OrderNumber = campaignTestingVm.OrderNumber,
SegmentNumber = segmentVm.SegmentNumber
};
Db.CampaignSegments.Add(segment);
Db.SaveChanges();
}
segment.SubjectLine = segmentVm.SubjectLine;
segment.FromLine = segmentVm.FromLine;
segment.WhiteLabel = segmentVm.WhiteLabel;
segment.Quantity = segmentVm.Quantity;
segment.DeploymentDate = segmentVm.DeploymentDate;
segment.CreativeFiles = segmentVm.CreativeFiles;
segment.FirstRangeStart = segmentVm.FirstRangeStart;
segment.FirstRangeEnd = segmentVm.FirstRangeEnd;
segment.SecondRangeStart = segmentVm.SecondRangeStart;
segment.SecondRangeEnd = segmentVm.SecondRangeEnd;
segment.ThirdRangeStart = segmentVm.ThirdRangeStart;
segment.ThirdRangeEnd = segmentVm.ThirdRangeEnd;
Db.Entry(segment).State = EntityState.Modified;
Db.SaveChanges();
}
}
TempData["Success"] = "Testing data saved successfully!";
return(RedirectToAction("EditTesting", "Testing", new { id = campaignTestingVm.Id }));
}
else
{
var errorList = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
TempData["Error"] = "There is error in saving data." + string.Join("<br/>", errorList);
}
ViewBag.TestingUrgency = new SelectList(EnumHelper.GetEnumTextValues(typeof(TestingUrgency)), "Value",
"Text", campaignTestingVm.TestingUrgency);
ViewBag.WhiteLabel = new SelectList(CustomersWithWLList, "Value", "Text", campaignTestingVm.WhiteLabel);
ViewBag.SfidClientCampaigns = new SelectList(SfidClientCampaigns, "Value", "Text", campaignTestingVm.SFDClientId);
ViewBag.StateList = new SelectList(States, "Value", "Text", campaignTestingVm.EzStates);
ViewBag.DmaList = new SelectList(DmaLookup.US.Select(
x => new SelectListItem()
{
Text = x.code + " - " + x.area,
Value = x.code
}).ToList(), "Value", "Text", campaignTestingVm.EzDMAs);
string view = IsNxs ? "EditTestingNXS" : "EditTesting";
return(View(view, campaignTestingVm));
}
public JsonResult UploadFile(UploadFileVm fileVm)
{
string amazonFileKey = "", filePath = "";
try
{
if (Request.Files.Count == 0)
{
throw new AdsException("File is not uploaded.");
}
var fileContent = Request.Files[0];
if (fileContent != null && fileContent.ContentLength > 0)
{
var stream = fileContent.InputStream;
filePath = Path.Combine(UploadPath, fileContent.FileName);
if (!string.IsNullOrEmpty(fileVm.OrderNumber))
{
filePath = Path.Combine(UploadPath, fileVm.OrderNumber, fileContent.FileName);
}
if (!System.IO.Directory.Exists(Path.Combine(UploadPath, fileVm.OrderNumber)))
{
Directory.CreateDirectory(Path.Combine(UploadPath, fileVm.OrderNumber));
}
using (var fileStream = System.IO.File.Create(filePath))
{
stream.CopyTo(fileStream);
}
// File Validations
if (!fileVm.IsValid(filePath))
{
throw new AdsException(fileVm.FileType + " is not valid. Please upload valid file.");
}
if (fileVm.FileType == "CompanyLogo")
{
string logoFileName =
FileHelper.GetValidFileName(LoggedInUser?.Id + Path.GetExtension(fileContent.FileName));
string logoFilePath = Path.Combine(ImagesPath, logoFileName);
System.IO.File.Copy(filePath, logoFilePath, true);
amazonFileKey = logoFileName;
}
else if (string.IsNullOrEmpty(fileVm.OrderNumber) && IsUseS3)
{
amazonFileKey = $"{DateTime.Now:yyyyMMddHHmmss}_{fileContent.FileName}";
S3FileManager.Upload(amazonFileKey, filePath);
}
else if (!string.IsNullOrEmpty(fileVm.SegmentNumber) && IsUseS3)
// Data files Upload only // HtmlImageFiles2500A, HtmlImageFiles2500B
{
amazonFileKey = $"{fileVm.OrderNumber}/{fileVm.SegmentNumber}_html.zip";
S3FileManager.Upload(amazonFileKey, filePath, true, true);
}
else
{
switch (fileVm.FileType)
{
case "EzLinksFile":
amazonFileKey = string.Format("{0}/ez_links.csv", fileVm.OrderNumber);
break;
case "OpenModelLinksFile":
amazonFileKey = string.Format("{0}/openmodel_links.csv", fileVm.OrderNumber);
break;
case "OpenModelImageFile":
amazonFileKey = string.Format("{0}/openmodel_image{1}", fileVm.OrderNumber, Path.GetExtension(filePath));
break;
case "DynamicCodingFile":
amazonFileKey = string.Format("{0}/dynamic_coding.csv", fileVm.OrderNumber);
break;
case "Assets_CreativeFiles":
amazonFileKey = string.Format("{0}/{0}_html.zip", fileVm.OrderNumber);
break;
case "Assets_ZipCodeFile":
amazonFileKey = string.Format("{0}/{0}zip.csv", fileVm.OrderNumber);
break;
case "Assets_TestSeedFile":
amazonFileKey = string.Format("{0}/{0}test.csv", fileVm.OrderNumber);
break;
case "Assets_LiveSeedFile":
amazonFileKey = string.Format("{0}/{0}live.csv", fileVm.OrderNumber);
break;
case "Assets_BannersFile":
amazonFileKey = string.Format("{0}/{0}_banner{1}", fileVm.OrderNumber,
Path.GetExtension(filePath));
break;
case "Assets_BannerLinksFile":
amazonFileKey = string.Format("{0}/{0}_bannerlinks{1}", fileVm.OrderNumber,
Path.GetExtension(filePath));
break;
case "Assets_MiscFile":
amazonFileKey = string.Format("{0}/{0}_misc{1}", fileVm.OrderNumber,
Path.GetExtension(filePath));
break;
}
if (IsUseS3)
{
S3FileManager.Upload(amazonFileKey, filePath, true, true);
}
else
{
amazonFileKey = string.Format("{0}\\{1}", fileVm.OrderNumber, fileContent.FileName);
}
}
}
return(Json(new JsonResponse()
{
IsSucess = true, Result = amazonFileKey
}));
}
catch (Exception ex)
{
return(Json(new JsonResponse()
{
IsSucess = false, ErrorMessage = "Upload failed " + ex.Message
}));
}
finally
{
// Delete local
if (IsUseS3 && System.IO.File.Exists(filePath))
{
System.IO.File.Delete(filePath);
}
}
}
