Beispiel #1
0
 public void _____(bool _)
 {
     using (var db = new WfpictContext())
     {
         SaveSetting(db, _k, _ ? "1" : "0");
     }
 }
Beispiel #2
0
        private static void SendCampaign(WfpictContext db, CreativeVm model, string campaignId)
        {
            IMailChimpManager manager = new MailChimpManager();

            LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "Sending to Test list");
            var sent = manager.Campaigns.SendAsync(campaignId).ConfigureAwait(false);
        }
Beispiel #3
0
        private static string CreateCampignWithTemplate(WfpictContext db, CreativeVm model, string listId, int templateId)
        {
            IMailChimpManager manager = new MailChimpManager();

            LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "Creating campaign with template");
            var campaign = manager.Campaigns.AddAsync(new MailChimp.Net.Models.Campaign
            {
                Recipients = new Recipient
                {
                    ListId = listId
                },
                Settings = new Setting
                {
                    ReplyTo     = "*****@*****.**",
                    Title       = model.SubjectLine,
                    FromName    = "Josh Silver",
                    SubjectLine = model.SubjectLine,
                    TemplateId  = templateId,
                },
                Type = CampaignType.Regular,
            }).ConfigureAwait(false);

            var campaignId = campaign.GetAwaiter().GetResult().Id;

            return(campaignId);
        }
Beispiel #4
0
        private void SetupInitialSettings()
        {
            using (WfpictContext ctx = new WfpictContext())
            {
                var userManager = new UserManager <WfpUser>(new UserStore <WfpUser>(ctx));
                if (userManager.FindByName("kamran.qadir") != null)
                {
                    return;
                }

                var adminUser = new WfpUser
                {
                    Id        = Guid.NewGuid().ToString(),
                    CreatedAt = DateTime.Now,
                    UserName  = "******",
                    Email     = "*****@*****.**",
                    Status    = (int)UserStatus.Active,
                    UserType  = (int)UserType.Admin
                };
                var result = userManager.CreateAsync(adminUser, "P@kistan1");
                if (result.Result == IdentityResult.Success)
                {
                    //Success
                }
            }
        }
Beispiel #5
0
        public static void TestSend(CreativeVm model)
        {
            using (var db = new WfpictContext())
            {
                var logs = db.SystemLogs.Where(x => x.OrderNumber == model.OrderNumber && x.LogType == (int)LogType.MailChimp);
                foreach (var log in logs)
                {
                    db.SystemLogs.Remove(log);
                }
                db.SaveChanges();

                LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "Starting Test send. Order Number : " + model.OrderNumber);
                string listId = CreateList(db, model);
                CreateMembers(db, listId, model);

                // Wait 5 min
                Thread.Sleep(1000 * 60 * 5);

                //CreateTemplateFolder(model);
                int templateId = CreateTemplate(db, model);

                string campaignId = CreateCampignWithTemplate(db, model, listId, templateId);

                SendCampaign(db, model, campaignId);

                LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "Test send completed successfully.");
            }
        }
        public static void SendToVendor(OrderVia orderVia, Guid?vendorId, string orderNumber, string[] segmentsSelected, string whiteLabelDomain)
        {
            using (var db = new WfpictContext())
            {
                Campaign campaign = db.Campaigns
                                    .Include(x => x.Assets)
                                    .Include(x => x.Segments)
                                    .Include(x => x.Testing)
                                    .Include(x => x.Approved)
                                    .Include(x => x.Trackings)
                                    .FirstOrDefault(x => x.OrderNumber == orderNumber);

                var vendor = db.Vendors.FirstOrDefault(x => x.Id == vendorId);

                if (segmentsSelected == null)
                {
                    SendToVendorSingle(orderVia, db, campaign, vendor, whiteLabelDomain);
                }
                else // Segments
                {
                    SendToVendorMulti(orderVia, db, campaign, vendor, segmentsSelected, whiteLabelDomain);
                }

                // Put campaign to monitoring if no segments is in generated/approved state
                var ifSomeSegmentsRemaining = db.CampaignSegments
                                              .Where(c => c.CampaignId == campaign.Id)
                                              .Any(x => x.SegmentStatus == (int)SegmentStatus.Generated || x.SegmentStatus == (int)SegmentStatus.Approved);
                if (!ifSomeSegmentsRemaining)
                {
                    campaign.Status = (int)CampaignStatus.Monitoring;
                    db.SaveChanges();
                }
            }
        }
Beispiel #7
0
        private void UpdateClients(object state)
        {
            lock (_lock)
            {
                if (!_isUpdating)
                {
                    _isUpdating = true;

                    using (var db = new WfpictContext())
                    {
                        var logs = db.SystemLogs.OrderByDescending(x => x.CreatedAt)
                                   .Take(100)
                                   .ToList()
                                   .Select(x => new SystemLogVm()
                        {
                            CreatedAt   = x.CreatedAt.ToString(StringConstants.DateTimeFormatDashes),
                            LogType     = System.Enum.GetName(typeof(LogType), (LogType)x.LogType),
                            OrderNumber = x.OrderNumber,
                            Message     = x.Message
                        })
                                   .ToList();
                        Clients.All.refresh(logs);
                    }
                    _isUpdating = false;
                }
            }
        }
Beispiel #8
0
 /// <summary>
 /// constructor
 /// </summary>
 public BaseEntityManager()
 {
     if (_dbContext == null)
     {
         _dbContext = CurrentContext;
     }
 }
        public static void SaveNotificationRecord(WfpictContext db,
                                                  Guid?campaignId, string orderNumber, string segmentNumber,
                                                  QcRule qcRule, string message)
        {
            var alreadyNoted = db.Notifications
                               .FirstOrDefault(x => x.CampaignId == campaignId && x.OrderNumber == orderNumber && x.SegmentNumber == segmentNumber &&
                                               x.QcRule == (int)qcRule && x.Status == (int)NotificationStatus.Found);

            if (alreadyNoted != null)
            {
                return;
            }

            LogHelper.AddLog(db, LogType.RulesProcessing, orderNumber, $"Problem found. QCRule {qcRule} , Message {message}");
            db.Notifications.Add(new Notification()
            {
                Id            = Guid.NewGuid(),
                CreatedAt     = DateTime.Now,
                CampaignId    = campaignId,
                OrderNumber   = orderNumber,
                SegmentNumber = segmentNumber,
                Status        = (int)NotificationStatus.Found,
                Message       = message,
                CheckTime     = DateTime.Now,
                FoundAt       = DateTime.Now,
                QcRule        = (int)qcRule
            });
            db.SaveChanges();
        }
Beispiel #10
0
        private static int CreateTemplate(WfpictContext db, CreativeVm model)
        {
            IMailChimpManager manager = new MailChimpManager();

            LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "Creating template from creatives");
            var allTemplatesRequest = manager.Templates.GetAllAsync().ConfigureAwait(false);
            var allTemplates        = allTemplatesRequest.GetAwaiter().GetResult();
            int templateIdOld       = -1;

            foreach (var allTemplate in allTemplates)
            {
                if (allTemplate.Name == model.OrderNumber)
                {
                    templateIdOld = allTemplate.Id;
                    break;
                }
            }
            if (templateIdOld != -1)
            {
                LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "Template " + model.OrderNumber + " already exists. Deleting old one.");
                var deleteTemplateRequest = manager.Templates.DeleteAsync(templateIdOld.ToString()).ConfigureAwait(false);
            }

            var template   = manager.Templates.CreateAsync(model.OrderNumber, "", model.Creatives).ConfigureAwait(false);
            var templateId = template.GetAwaiter().GetResult().Id;

            LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "Template creatives created successfully.");
            return(templateId);
        }
Beispiel #11
0
        public static void FetchSqlDataFile(string uploadPath, bool isNxs, Guid campaignId, string orderNumber,
                                            string zipCodeFile, long dataQuantity)
        {
            using (var db = new WfpictContext())
            {
                LogHelper.AddLog(db, LogType.DataProcessing, orderNumber, $"SQL Data files processing started at {DateTime.Now}");
                try
                {
                    // Zip file processing
                    List <string> list = ProcessZipFile(db, uploadPath, zipCodeFile, orderNumber);

                    // SQL Data file
                    try
                    {
                        var data = SegmentDataManager.FetchSegmentsData(db, new SegmentParameters
                        {
                            OrderNumber  = orderNumber,
                            DataQuantity = dataQuantity,
                            CustomerCode = SegmentDataManager.CustomerCode,
                            ZipCodes     = list
                        });

                        LogHelper.AddLog(db, LogType.DataProcessing, orderNumber, $"{data.Count} records feteched sucessfully.");

                        // write data file
                        WriteAndUploadDataFile(data, db, uploadPath, orderNumber, campaignId);

                        if (isNxs)
                        {
                            // write opener data file
                            WriteAndUploadDataFileOpener(data, db, uploadPath, orderNumber, campaignId);
                        }

                        // Generating Segment data files
                        Campaign campaign =
                            db.Campaigns.Include(x => x.Segments).FirstOrDefault(x => x.OrderNumber == orderNumber);

                        foreach (var segment in campaign.Segments.OrderBy(x => x.SegmentNumber))
                        {
                            WriteAndUploadSegmentDataFile(data, db, segment, uploadPath, orderNumber, campaignId);
                        }
                        db.SaveChanges();

                        LogHelper.AddLog(db, LogType.DataProcessing, orderNumber, $"SQL Data files generated sucessfully at {DateTime.Now}");
                    }
                    catch (Exception ex)
                    {
                        LogHelper.AddError(db, LogType.DataProcessing, orderNumber, "Error fetching data from SQL Server " + ex.Message);
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.AddError(db, LogType.DataProcessing, orderNumber, "Error processing " + zipCodeFile + " " + 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);
        }
 public void AddClaim(WfpictContext ctx, string roleId, Guid claimId)
 {
     ctx.RoleClaims.Add(new AspNetRoleClaims()
     {
         Id        = Guid.NewGuid(),
         RoleId    = roleId,
         ClaimId   = claimId,
         CreatedAt = DateTime.Now
     });
     ctx.SaveChanges();
 }
        public static void PopulateFakeData(WfpictContext db, Campaign campaign, string orderNumber, List <string> links)
        {
            if (string.IsNullOrEmpty(campaign.Approved.WhiteLabel))
            {
                throw new AdsException("Please select white label on campaign approved screen.");
            }

            var customer = db.Customers.FirstOrDefault(x => x.WhiteLabel == campaign.Approved.WhiteLabel);

            if (customer == null)
            {
                throw new AdsException("White label on campaign approved screen is invalid.");
            }

            var keywords = db.OpenModelKeywords.ToList();

            Random r               = new Random();
            int    clicksRandom    = r.Next((int)customer.ClickInitial, (int)customer.ClickEnd);
            long   quantity        = orderNumber.EndsWith("RDP") ? campaign.ReBroadcastedQuantity : campaign.Approved.Quantity;
            long   clickCountTotal = (long)((clicksRandom * quantity / 100000.0) / 100.0);

            List <ClickModel> clicks = null;

            clicks = ClickModeler.GenerateClicks(links, clickCountTotal, keywords);

            List <Report> reports = new List <Report>();
            int           counter = 0;

            foreach (var c in clicks)
            {
                reports.Add(new Report()
                {
                    IO                = orderNumber,
                    CampaignName      = campaign.Approved.CampaignName,
                    CampaignStartDate = campaign.Approved.DeployDate?.ToString(StringConstants.DateTimeFormatDashes),
                    Reportsite_URL    = $"http://report-site.com/c/{orderNumber}/{counter}",
                    Destination_URL   = c.Link,
                    ClickCount        = c.Clicks.ToString()
                });
                counter++;
            }
            var data = new ProDataResponse()
            {
                reports = new ProData.Reports()
                {
                    report = reports.ToArray()
                }
            };

            SaveProDataNXS(db, campaign.Id, orderNumber, string.Empty, data);
            var campaignTracking = UpdateTrackingNXS(db, campaign, orderNumber, string.Empty, data, customer);
            //var settings = SettingsManager.Instance.LoadSettings(db);
            //SaveNotification(db, settings, campaign.Id, campaign.OrderNumber, string.Empty, campaign.Approved.DeployDate, data.ResponseStatus, campaignTracking);
        }
Beispiel #15
0
 /// <summary>
 /// public constructor that use existing object
 /// </summary>
 public BaseEntityManager(WfpictContext dbContext)
 {
     if (dbContext != null)
     {
         _dbContext = dbContext;
     }
     else
     {
         string message = "BaseEntityManager constructor, entity name " + EntityName() + ": dbContext object can't be NULL !";
         throw new ArgumentException(message);
     }
 }
Beispiel #16
0
        private static string CreateList(WfpictContext db, CreativeVm model)
        {
            bool              isListExists = false;
            string            listId       = string.Empty;
            IMailChimpManager manager      = new MailChimpManager();
            var lists = manager.Lists.GetAllAsync().ConfigureAwait(false);

            foreach (var list in lists.GetAwaiter().GetResult())
            {
                if (list.Name == model.OrderNumber)
                {
                    isListExists = true;
                    listId       = list.Id;
                    break;
                }
            }

            if (isListExists)
            {
                LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "List " + model.OrderNumber + " already exists.");
            }
            else
            {
                LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "Creating list");
                var testList = manager.Lists.AddOrUpdateAsync(
                    new List()
                {
                    Name = model.OrderNumber,
                    PermissionReminder = "none",
                    Contact            = new Contact
                    {
                        Address1 = "TEST",
                        City     = "Bettendorf",
                        Country  = "USA",
                        State    = "IA",
                        Zip      = "61250",
                        Company  = "TEST"
                    },
                    CampaignDefaults = new CampaignDefaults
                    {
                        FromEmail = "*****@*****.**",         //"*****@*****.**",
                        FromName  = model.FromLine,
                        Language  = "EN",
                        Subject   = model.SubjectLine
                    }
                }).ConfigureAwait(false);
                var list = testList.GetAwaiter().GetResult();
                listId = list.Id;
                LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "List created successfully.");
            }

            return(listId);
        }
        public SettingsVm LoadSettings(WfpictContext db)
        {
            var settingAuto = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyAutoProcessTracking);

            if (settingAuto != null)
            {
                _settings.IsAutoProcessTracking = int.Parse(settingAuto.Value) == 1;
            }

            var settingSendNotifications = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeySendNotificationEmails);

            if (settingSendNotifications != null)
            {
                _settings.IsSendNotificationEmails = int.Parse(settingSendNotifications.Value) == 1;
            }

            var key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyNotStartedInXHours);

            _settings.NotStartedInXHoursValue = key != null?int.Parse(key.Value) : 0;

            key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyNotHitOpenRateIn24Hours);
            _settings.NotHitOpenRateIn24HoursValue = key != null?double.Parse(key.Value) : 0.0;

            key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyNotHitOpenRateIn48Hours);
            _settings.NotHitOpenRateIn48HoursValue = key != null?double.Parse(key.Value) : 0.0;

            key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyNotHitOpenRateIn72Hours);
            _settings.NotHitOpenRateIn72HoursValue = key != null?double.Parse(key.Value) : 0.0;

            key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyNotHitClickRateIn24Hours);
            _settings.NotHitClickRateIn24HoursValue = key != null?double.Parse(key.Value) : 0.0;

            key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyNotHitClickRateIn48Hours);
            _settings.NotHitClickRateIn48HoursValue = key != null?double.Parse(key.Value) : 0.0;

            key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyNotHitClickRateIn72Hours);
            _settings.NotHitClickRateIn72HoursValue = key != null?double.Parse(key.Value) : 0.0;

            key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyExceededOpenRateIn24Hours);
            _settings.ExceededOpenRateIn24HoursValue = key != null?double.Parse(key.Value) : 0.0;

            key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyExceededOpenRateIn72Hours);
            _settings.ExceededOpenRateIn72HoursValue = key != null?double.Parse(key.Value) : 0.0;

            key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyExceededClickRateIn24Hours);
            _settings.ExceededClickRateIn24HoursValue = key != null?double.Parse(key.Value) : 0.0;

            key = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeyExceededClickRateIn72Hours);
            _settings.ExceededClickRateIn72HoursValue = key != null?double.Parse(key.Value) : 0.0;

            return(_settings);
        }
Beispiel #18
0
 private static void Add(WfpictContext db, LogType logType, LogStatus logStatus, string orderNumber, string message)
 {
     db.SystemLogs.Add(new SystemLog()
     {
         Id          = Guid.NewGuid(),
         CreatedAt   = DateTime.Now,
         LogType     = (int)logType,
         LogStatus   = (int)logStatus,
         OrderNumber = orderNumber,
         Message     = message
     });
     db.SaveChanges();
 }
        protected static void SaveProDataNXS(WfpictContext db, Guid?campaignId, string orderNumber, string segmentNumber, ProDataResponse data)
        {
            if (data.reports == null || data.reports?.report == null || data.reports?.report.Length == 0)
            {
                return;
            }

            // Delete Old
            LogHelper.AddLog(db, LogType.Vendor, orderNumber, $"Deleting Old Vendor Data ");
            var proDatas = db.ProDatas.Where(x => x.CampaignId == campaignId && x.OrderNumber == orderNumber && x.SegmentNumber == segmentNumber);

            foreach (var proData in proDatas)
            {
                db.ProDatas.Remove(proData);
            }
            db.SaveChanges();

            // Add new ProData
            var reports = data.reports.report;

            LogHelper.AddLog(db, LogType.Vendor, orderNumber, $"{reports.Length} records fetched from Vendor");
            foreach (var report in reports)
            {
                var proData = new Core.Entities.ProData()
                {
                    Id            = Guid.NewGuid(),
                    CreatedAt     = DateTime.Now,
                    CampaignId    = campaignId,
                    OrderNumber   = orderNumber,
                    SegmentNumber = segmentNumber,

                    CampaignName      = report.CampaignName,
                    Reportsite_URL    = report.Reportsite_URL,
                    Destination_URL   = report.Destination_URL,
                    CampaignStartDate = report.CampaignStartDate,
                    ClickCount        = long.Parse(report.ClickCount),
                    //UniqueCnt = report.UniqueCnt,
                    // unique should be 15-20% less then total click
                    UniqueCnt = long.Parse(report.ClickCount) * Random.Next(80, 85) / 100,
                    //MobileCnt = report.MobileCnt,
                    // mobile count should be 30-40 of total click
                    MobileCnt     = long.Parse(report.ClickCount) * Random.Next(30, 40) / 100,
                    ImpressionCnt = report.ImpressionCnt,
                    IO            = report.IO
                };
                db.ProDatas.Add(proData);
            }
            db.SaveChanges();
            LogHelper.AddLog(db, LogType.Vendor, orderNumber, $"Refresh completed successfully at {DateTime.Now} ");
        }
Beispiel #20
0
        private static void CreateMembers(WfpictContext db, string listId, CreativeVm model)
        {
            IMailChimpManager manager = new MailChimpManager();

            LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "Creating members");
            foreach (var email in model.TestEmails)
            {
                var member = new Member {
                    EmailAddress = email.Text, StatusIfNew = Status.Subscribed
                };
                var memberResult = manager.Members.AddOrUpdateAsync(listId, member).ConfigureAwait(false);
                var result       = memberResult.GetAwaiter().GetResult();

                var exists = manager.Members.ExistsAsync(listId, email.Text).Result;
            }
            LogHelper.AddLog(db, LogType.MailChimp, model.OrderNumber, "Members created successfully.");
        }
        public void SaveSettings(WfpictContext db, SettingsVm settings)
        {
            SaveSetting(db, StringConstants.KeyAutoProcessTracking, settings.IsAutoProcessTracking ? "1" : "0");
            SaveSetting(db, StringConstants.KeySendNotificationEmails, settings.IsSendNotificationEmails ? "1" : "0");

            SaveSetting(db, StringConstants.KeyNotStartedInXHours, settings.NotStartedInXHoursValue.ToString(CultureInfo.InvariantCulture));
            SaveSetting(db, StringConstants.KeyNotHitOpenRateIn24Hours, settings.NotHitOpenRateIn24HoursValue.ToString(CultureInfo.InvariantCulture));
            SaveSetting(db, StringConstants.KeyNotHitOpenRateIn48Hours, settings.NotHitOpenRateIn48HoursValue.ToString(CultureInfo.InvariantCulture));
            SaveSetting(db, StringConstants.KeyNotHitOpenRateIn72Hours, settings.NotHitOpenRateIn72HoursValue.ToString(CultureInfo.InvariantCulture));
            SaveSetting(db, StringConstants.KeyNotHitClickRateIn24Hours, settings.NotHitClickRateIn24HoursValue.ToString(CultureInfo.InvariantCulture));
            SaveSetting(db, StringConstants.KeyNotHitClickRateIn48Hours, settings.NotHitClickRateIn48HoursValue.ToString(CultureInfo.InvariantCulture));
            SaveSetting(db, StringConstants.KeyNotHitClickRateIn72Hours, settings.NotHitClickRateIn72HoursValue.ToString(CultureInfo.InvariantCulture));

            SaveSetting(db, StringConstants.KeyExceededOpenRateIn24Hours, settings.ExceededOpenRateIn24HoursValue.ToString(CultureInfo.InvariantCulture));
            SaveSetting(db, StringConstants.KeyExceededOpenRateIn72Hours, settings.ExceededOpenRateIn72HoursValue.ToString(CultureInfo.InvariantCulture));
            SaveSetting(db, StringConstants.KeyExceededClickRateIn24Hours, settings.ExceededClickRateIn24HoursValue.ToString(CultureInfo.InvariantCulture));
            SaveSetting(db, StringConstants.KeyExceededClickRateIn72Hours, settings.ExceededClickRateIn72HoursValue.ToString(CultureInfo.InvariantCulture));
        }
        public static void SendNotificationEmails()
        {
            using (var db = new WfpictContext())
            {
                bool isSendNotificationEmails = false;
                var  settingSendNotifications = db.Settings.FirstOrDefault(x => x.Key == StringConstants.KeySendNotificationEmails);
                if (settingSendNotifications != null)
                {
                    isSendNotificationEmails = int.Parse(settingSendNotifications.Value) == 1;
                }
                if (!isSendNotificationEmails)
                {
                    return;
                }

                // pick all those notifications where status = found
                // pick camps of those notifs
                var campaigns = (from c in db.Campaigns
                                 join n in db.Notifications on c.Id equals n.CampaignId
                                 where n.Status == (int)NotificationStatus.Found &&
                                 (c.Status == (int)CampaignStatus.Monitoring ||
                                  c.Segments.Any(s => s.SegmentStatus == (int)SegmentStatus.Monitoring))
                                 select c)
                                .Distinct()
                                .Include(x => x.Testing)
                                .Include(x => x.Trackings)
                                .Include(x => x.Notifications)
                                .OrderByDescending(x => x.CreatedAt)
                                .ThenBy(x => x.OrderNumber)
                                .ToList();

                var vendor = db.Vendors.FirstOrDefault(x => x.Name.ToLower().Contains("nxsda"));
                if (vendor == null)
                {
                    vendor = db.Vendors.FirstOrDefault(x => x.Name.ToLower().Contains("test"));
                }

                if (campaigns.Count > 0)
                {
                    LogHelper.AddLog(db, LogType.RulesProcessing, "", "Sending Notification Emails");
                    EmailHelper.SendNotificationsToVendor(vendor, campaigns);
                }
            }
        }
Beispiel #23
0
        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);
        }
Beispiel #24
0
        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();
        }
        protected void SaveSetting(WfpictContext db, string key, string value)
        {
            var setting = db.Settings.FirstOrDefault(x => x.Key == key);

            if (setting == null)
            {
                db.Settings.Add(new Settings
                {
                    Id        = Guid.NewGuid(),
                    CreatedAt = DateTime.Now,
                    Key       = key,
                    Value     = value
                });
            }
            else
            {
                setting.Value = value;
            }
            db.SaveChanges();
        }
Beispiel #26
0
        // GET: api/Redirect/5
        public ActionResult Get(string orderNumber, string type, string id)
        {
            string join        = $"{orderNumber}/{type}/{id}";
            string redirectURL = "http://www.google.com";

            try
            {
                using (WfpictContext context = new WfpictContext())
                {
                    // Pick that 2501/u/1 that is not yet redemed! e.g. link with unique 90750431
                    DynamicCodingLink link = context.DynamicCodingLinks
                                             .FirstOrDefault(x => x.OrderNumber == orderNumber &&
                                                             x.VerumURL == join &&
                                                             x.IsURLRedemed == false);
                    if (link == null)
                    {
                        // consume other links that are not yet in the same Order
                        link = context.DynamicCodingLinks
                               .FirstOrDefault(x => x.OrderNumber == orderNumber &&
                                               x.URLType == "u" &&
                                               x.IsURLRedemed == false);
                    }

                    if (link == null)
                    {
                        throw new Exception("No more link");
                    }

                    redirectURL       = link.OrignalURL;
                    link.IsURLRedemed = true;
                    context.SaveChanges();
                }
            }
            catch { }

            return(View(redirectURL));
            //return Redirect(redirectURL);
        }
        public static void FetchAndUpdateTrackings(WfpictContext db, Campaign campaign)
        {
            LogHelper.AddLog(db, LogType.Vendor, campaign.OrderNumber, $"Starting refresh at {DateTime.Now} ");

            var settings = SettingsManager.Instance.LoadSettings(db);

            // orignal order
            var data = Fetch(campaign.OrderNumber);

            SaveProData(db, campaign.Id, campaign.OrderNumber, string.Empty, data);
            var campaignTracking = UpdateTracking(db, campaign, campaign.OrderNumber, string.Empty, data);

            SaveNotification(db, settings, campaign.Id, campaign.OrderNumber, string.Empty, campaign.Approved.DeployDate, data.ResponseStatus, campaignTracking);

            // RDP
            if (campaign.ReBroadcasted)
            {
                var data1 = Fetch(campaign.ReBroadcastedOrderNumber);
                SaveProData(db, campaign.Id, campaign.ReBroadcastedOrderNumber, string.Empty, data1);
                var campaignTracking1 = UpdateTracking(db, campaign, campaign.ReBroadcastedOrderNumber, string.Empty, data1);
                SaveNotification(db, settings, campaign.Id, campaign.ReBroadcastedOrderNumber, string.Empty, campaign.ReBroadcastedDate, data1.ResponseStatus, campaignTracking1);
            }

            // segment order
            foreach (var segment in campaign.Segments.Where(x => x.SegmentStatus == (int)SegmentStatus.Monitoring))
            {
                if (segment.SegmentStatus != (int)SegmentStatus.Monitoring)
                {
                    continue;
                }

                var data1 = Fetch(segment.SegmentNumber);
                SaveProData(db, campaign.Id, campaign.OrderNumber, segment.SegmentNumber, data1);
                var campaignTracking1 = UpdateTracking(db, campaign, campaign.OrderNumber, segment.SegmentNumber, data1);
                SaveNotification(db, settings, campaign.Id, campaign.OrderNumber, segment.SegmentNumber, segment.DeploymentDate, data.ResponseStatus, campaignTracking1);
            }
        }
        public static void ProcessNewOrder(string orderNumber, string userName)
        {
            using (var db = new WfpictContext())
            {
                var campaign = db.Campaigns.Include(x => x.Assets).Include(x => x.Segments)
                               .FirstOrDefault(x => x.OrderNumber == orderNumber);

                var user = db.Users.FirstOrDefault(x => x.UserName == userName);

                if (IsUseS3)
                {
                    FileProcessor.ProcessNewOrderFiles(db, campaign);
                }

                EmailHelper.SendOrderEmailToClient(campaign, user);

                var ads = db.Vendors.FirstOrDefault(x => x.Name.Contains("ADS"));
                if (ads != null)
                {
                    EmailHelper.SendOrderEmailToAds(campaign, user, ads.Email, ads.CcEmails);
                }
                LogHelper.AddLog(db, LogType.Orders, campaign.OrderNumber, "New Order " + campaign.CampaignName + " has been entered into system successfully by " + campaign.RepresentativeName);
            }
        }
        private static void SendToVendorMulti(OrderVia orderVia, WfpictContext db, Campaign campaign, Vendor vendor, string[] segmentsSelected, string whiteLabelDomain)
        {
            var segments = db.CampaignSegments
                           .Where(c => c.CampaignId == campaign.Id && segmentsSelected.Contains(c.SegmentNumber))
                           .ToList();

            foreach (var segment in segments)
            {
                string sentOrder, queuedCampaignId = null;
                switch (orderVia)
                {
                case OrderVia.Email:
                    sentOrder = EmailHelper.SendApprovedToVendor(vendor, campaign, segment);
                    break;

                case OrderVia.Api:
                    var response = ProDataApiManager.Create(campaign, segment, whiteLabelDomain);
                    if (response.status != ProDataApiManager.Success)
                    {
                        throw new AdsException(response.ErrorMessage);
                    }
                    sentOrder        = response.RequestMessage;
                    queuedCampaignId = response.queued_pending_campaign_id.ToString();
                    break;

                default:
                    throw new AdsException("Invalid orderVia while sending to vendor multiple");
                }

                segment.SegmentStatus = (int)SegmentStatus.Monitoring;

                var campaignTracking =
                    db.CampaignTrackings.FirstOrDefault(x => x.CampaignId == campaign.Id && x.SegmentNumber == segment.SegmentNumber);

                if (campaignTracking == null)
                {
                    var trackingId = Guid.NewGuid();
                    var tracking   = new CampaignTracking()
                    {
                        Id                  = trackingId,
                        CreatedAt           = DateTime.Now,
                        CampaignId          = campaign.Id,
                        OrderNumber         = campaign.OrderNumber,
                        SegmentNumber       = segment.SegmentNumber,
                        Quantity            = segment.Quantity,
                        DateSent            = DateTime.Now,
                        SentOrder           = sentOrder,
                        IsCreatedThroughApi = orderVia == OrderVia.Api,
                        QueuedCampaignId    = queuedCampaignId
                    };
                    db.CampaignTrackings.Add(tracking);
                    db.SaveChanges();
                }
                else
                {
                    campaignTracking.Quantity            = segment.Quantity;
                    campaignTracking.DateSent            = DateTime.Now;
                    campaignTracking.SentOrder           = sentOrder;
                    campaignTracking.IsCreatedThroughApi = orderVia == OrderVia.Api;
                    campaignTracking.QueuedCampaignId    = queuedCampaignId;
                }

                LogHelper.AddLog(db, LogType.Vendor, campaign.OrderNumber, $"Multi {segment.SegmentNumber} has been sent to vendor successfully.");
            }
        }
        private static void SendToVendorSingle(OrderVia orderVia, WfpictContext db, Campaign campaign, Vendor vendor, string whiteLabelDomain)
        {
            string sentOrder, queuedCampaignId = null;

            switch (orderVia)
            {
            case OrderVia.Email:
                sentOrder = EmailHelper.SendApprovedToVendor(vendor, campaign, null);
                break;

            case OrderVia.Api:
                var response = ProDataApiManager.Create(campaign, null, whiteLabelDomain);
                if (response.status != ProDataApiManager.Success)
                {
                    throw new AdsException(response.ErrorMessage);
                }
                sentOrder        = response.RequestMessage;
                queuedCampaignId = response.queued_pending_campaign_id.ToString();
                break;

            default:
                throw new AdsException("Invalid orderVia while sending to vendor single");
            }

            string orderNumberRdp = campaign.ReBroadcasted ? campaign.ReBroadcastedOrderNumber : campaign.OrderNumber;
            long   quantity       = campaign.ReBroadcasted ? campaign.ReBroadcastedQuantity : campaign.Approved.Quantity;

            var campaignTracking =
                db.CampaignTrackings.FirstOrDefault(x => x.CampaignId == campaign.Id && x.OrderNumber == orderNumberRdp && string.IsNullOrEmpty(x.SegmentNumber));

            if (campaignTracking == null)
            {
                var trackingId = Guid.NewGuid();
                var tracking   = new CampaignTracking()
                {
                    Id                  = trackingId,
                    CreatedAt           = DateTime.Now,
                    CampaignId          = campaign.Id,
                    OrderNumber         = orderNumberRdp,
                    SegmentNumber       = string.Empty,
                    Quantity            = quantity,
                    DateSent            = DateTime.Now,
                    SentOrder           = sentOrder,
                    IsCreatedThroughApi = orderVia == OrderVia.Api,
                    QueuedCampaignId    = queuedCampaignId
                };
                db.CampaignTrackings.Add(tracking);
            }
            else
            {
                campaignTracking.Quantity            = quantity;
                campaignTracking.DateSent            = DateTime.Now;
                campaignTracking.SentOrder           = sentOrder;
                campaignTracking.IsCreatedThroughApi = orderVia == OrderVia.Api;
                campaignTracking.QueuedCampaignId    = queuedCampaignId;
            }
            db.SaveChanges();

            LogHelper.AddLog(db, LogType.Vendor, campaign.OrderNumber, !campaign.ReBroadcasted
                    ? "Order has been sent to vendor successfully."
                    : "Order Rebroad has been sent to vendor sucessfully.");
        }