public TestController(ITestTableService _testService, IRequestInfo <TemplateContext> _requestinfo, ILogger <TestController> logger, IBackgroundJobService backgroundJobService)
{
this.testService = _testService;
this.requestInfo = _requestinfo;
this._logger = logger;
_backgroundJobService = backgroundJobService;
}
public void RecoverAccount(long accountId, IBackgroundJobService backgroundJobService)
{
new RecoverUserCommandHandler(new DataBaseContext()).Handle(new RecoverUserCommand
{
AccountId = accountId
});
var account = new GetAccountByIdQueryHandler(new DataBaseContext()).Handle(new GetAccountByIdQuery
{
UserId = accountId
});
new CookieService().RefreshCookies(new AccountViewModel
{
Id = accountId,
Login = account.Login,
Password = account.Password,
Proxy = account.Proxy,
ProxyLogin = account.ProxyLogin,
ProxyPassword = account.ProxyPassword,
UserAgentId = account.UserAgentId
},
forSpy: false,
backgroundJob: backgroundJobService);
if (account.GroupSettingsId == null)
{
return;
}
var settings = _accountSettingsManager.GetSettings((long)account.GroupSettingsId);
var accountViewModel = new AccountViewModel
{
Id = account.Id,
AuthorizationDataIsFailed = account.AuthorizationDataIsFailed,
Cookie = account.Cookie.CookieString,
IsDeleted = account.IsDeleted,
ProxyDataIsFailed = account.ProxyDataIsFailed,
GroupSettingsId = account.GroupSettingsId,
Name = account.Name,
Proxy = account.Proxy,
FacebookId = account.FacebookId,
Login = account.Login,
PageUrl = account.PageUrl,
Password = account.Password,
ProxyLogin = account.ProxyLogin,
ProxyPassword = account.ProxyPassword,
ConformationDataIsFailed = account.ConformationIsFailed,
UserAgentId = account.UserAgentId
};
var model = new AddOrUpdateAccountModel()
{
Account = accountViewModel,
NewSettings = settings,
OldSettings = null
};
backgroundJobService.AddOrUpdateAccountJobs(model);
}
public MediaManager(AppDbContext db, IMapper mapper, IEnumerable <IMediaHandler> mediaHandlers, IBackgroundJobService jobSvc)
{
_db = db;
_mapper = mapper;
_jobSvc = jobSvc;
_mediaHandlers = mediaHandlers.ToArray();
}
public CreateOrderCommandHandler(IDbContext dbContext,
IMapper mapper,
IBackgroundJobService backgroundJobService,
ICurrentUserService currentUserService)
{
_dbContext = dbContext;
_mapper = mapper;
_backgroundJobService = backgroundJobService;
_currentUserService = currentUserService;
}
public HomeService(IJobService jobService, IBackgroundJobService backgroundJobService)
{
_accountManager = new AccountManager();
_accountSettingsManager = new AccountSettingsManager();
_accountStatisticsManager = new StatisticsManager();
_proxyManager = new ProxyManager();
_jobService = jobService;
_jobQueueService = new JobQueueService();
_backgroundJobService = backgroundJobService;
}
private static void UpdateJobsTask(IBackgroundJobService backgroundJobService, AccountViewModel account, GroupSettingsViewModel newSettings, GroupSettingsViewModel oldSettings)
{
var model = new AddOrUpdateAccountModel
{
Account = account,
NewSettings = newSettings,
OldSettings = oldSettings
};
backgroundJobService.AddOrUpdateAccountJobs(model);
}
public MailService(
IBackgroundJobService backgroundJobService,
IFluentEmail email,
IViewRenderer viewRenderer,
IServiceProvider serviceProvider
)
{
_backgroundJobService = backgroundJobService;
_email = email;
_viewRenderer = viewRenderer;
_serviceProvider = serviceProvider;
}
public RandomLikeService(
IVkWallService vkClient,
ISecurityUserManager securityUserManager,
ITransactionScopeFactory transactionScopeFactory,
IBackgroundJobService schedulerJobService,
IVkLikeService vkLikeService
)
{
_vkClient = vkClient;
_securityUserManager = securityUserManager;
_transactionScopeFactory = transactionScopeFactory;
_backgroundJobService = schedulerJobService;
_vkLikeService = vkLikeService;
}
public TargetService(
ICrudRepository <Target, TargetDto> targetRepository,
IUserService userService,
ILogger <TargetService> logger,
ICrudRepository <HealthCheck, HealthCheckDto> healthRepository,
IMapper mapper,
IBackgroundJobService jobService,
ITargetRepository targetUpdateRepository)
{
_targetRepository = targetRepository;
_userService = userService;
_logger = logger;
_healthRepository = healthRepository;
_mapper = mapper;
_jobService = jobService;
_targetUpdateRepository = targetUpdateRepository;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//services.AddDbContext<ApplicationDbContext>(
// options => options.UseSqlServer("data source=192.168.31.51;initial catalog=UserWebApp;user id=sa;password=Sixlogics123;MultipleActiveResultSets=True;"));
services.Configure<CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddIdentity<IdentityUser, IdentityRole>().AddEntityFrameworkStores<ApplicationDbContext>();
services.AddHttpContextAccessor();
services.AddRouting();
services.AddDetection();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
//add CORS
services.AddCors(c =>
{
c.AddPolicy("AllowOrigin", options => options.AllowAnyOrigin());
});
this._RegisterApplicationServices(services);
this._RegisterRepositories(services);
this._RegisterServices(services);
this._RegisterBusinessOperations(services);
// SignalR Library
services.AddSignalR().AddJsonProtocol(options =>
{
options.PayloadSerializerSettings.ContractResolver = new DefaultContractResolver();
});
ServiceProvider serviceProvider = services.BuildServiceProvider();
IBackgroundJobService backgroundJobService = serviceProvider.GetService<IBackgroundJobService>();
backgroundJobService.ScheduleAutoSignalR();
}
public StartupService(IBackgroundJobService backgroundJobService)
{
_backgroundJobService = backgroundJobService;
}
public NewFriendListViewModel GetNewFriendsAndRecommended(AccountViewModel account, IBackgroundJobService backgroundJobService)
{
const string functionName = "Получение реком. друзей";
if (account.GroupSettingsId == null)
{
_notice.AddNotice(functionName, account.Id, "Ошибка! Не выбрана группа настрект.");
return(null);
}
var accountModel = _accountManager.GetAccountById(account.Id);
_notice.AddNotice(functionName, account.Id, "Получаем рекомендованных друзей");
var userAgent = new GetUserAgentQueryHandler(new DataBaseContext()).Handle(new GetUserAgentQuery
{
UserAgentId = account.UserAgentId
});
var friendListResponseModels = new GetRecommendedFriendsEngine().Execute(new GetRecommendedFriendsModel
{
Cookie = accountModel.Cookie,
Proxy = _accountManager.GetAccountProxy(accountModel),
UserAgent = userAgent.UserAgentString
});
_notice.AddNotice(functionName, account.Id,
string.Format("Список рекомендованных друзей получен - {0}. Входящих заявок - {1}", friendListResponseModels.Friends.Count(model => model.Type == FriendTypes.Recommended), friendListResponseModels.Friends.Count(model => model.Type == FriendTypes.Incoming)));
var friendList = friendListResponseModels.Friends.Select(model => new AnalysisFriendData
{
AccountId = accountModel.Id,
FacebookId = model.FacebookId,
Type = model.Type,
Status = StatusesFriend.ToAnalys,
FriendName = model.FriendName
}).ToList();
//Check
_notice.AddNotice(functionName, account.Id, "Проверяем не общались ли мы с этими друзьями");
var certifiedListFriends = _analysisFriendsManager.CheckForAnyInDataBase(accountModel, friendList, _notice, functionName);
_notice.AddNotice(functionName, account.Id, "Сохраняем рекомендованных друзей");
new SaveFriendsForAnalysisCommandHandler(new DataBaseContext()).Handle(new SaveFriendsForAnalysisCommand
{
AccountId = accountModel.Id,
Friends = certifiedListFriends
});
var countIncomming = certifiedListFriends.Count(data => data.Type == FriendTypes.Incoming) != 0
? friendListResponseModels.CountIncommingFriends
: certifiedListFriends.Count(data => data.Type == FriendTypes.Incoming); //если есть вообще рекомендуемые друзья, иначе надпись лейба будет браться с рекомендация для добавления
new AddAccountInformationCommandHandler(new DataBaseContext()).Handle(new AddAccountInformationCommand
{
AccountId = account.Id,
AccountInformationData = new AccountInformationDataDbModel
{
CountIncommingFriendsRequest = countIncomming
}
});
_notice.AddNotice(functionName, account.Id, "Получение рекомендованных друзей завершено.");
return(new NewFriendListViewModel
{
AccountId = accountModel.Id,
NewFriends = friendList.Select(model => new NewFriendViewModel
{
FacebookId = model.FacebookId,
FriendName = model.FriendName,
Gender = model.Gender,
Type = model.Type,
Uri = model.Uri
}).ToList()
});
}
public CreateInvoiceCommandHandler(IDbContext context, IMapper mapper, IBackgroundJobService backgroundJobService)
{
_dbContext = context;
_mapper = mapper;
_backgroundJobService = backgroundJobService;
}
public long AddOrUpdateAccount(AccountDraftViewModel model, IBackgroundJobService backgroundJobService)
{
var userAgentId = new GetRandomUserAgentQueryHandler(new DataBaseContext()).Handle(new GetRandomUserAgentQuery());
if (userAgentId == null)
{
return(0);
}
var accountId = new AddOrUpdateAccountCommandHandler(new DataBaseContext()).Handle(new AddOrUpdateAccountCommand
{
Id = model.Id,
Name = model.Name,
PageUrl = model.PageUrl,
FacebookId = model.FacebookId,
Password = model.Password,
Login = model.Login,
Proxy = model.Proxy,
ProxyLogin = model.ProxyLogin,
ProxyPassword = model.ProxyPassword,
UserAgentId = userAgentId.Id
});
new CookieService().RefreshCookies(new AccountViewModel
{
Id = accountId,
Login = model.Login,
Password = model.Password,
Proxy = model.Proxy,
ProxyLogin = model.ProxyLogin,
ProxyPassword = model.ProxyPassword,
UserAgentId = model.UserAgentId
},
false,
backgroundJobService);
var account = new GetAccountByIdQueryHandler(new DataBaseContext()).Handle(new GetAccountByIdQuery
{
UserId = accountId
});
if (model.Id == null || model.PageUrl == null || model.FacebookId == 0)
{
long accountFacebookId = 0;
string homePageUrl = null;
if (account.Cookie != null)
{
accountFacebookId = _proxyManager.GetAccountFacebookId(account.Cookie.CookieString);
homePageUrl = _accountManager.CreateHomePageUrl(accountFacebookId);
}
new AddOrUpdateAccountCommandHandler(new DataBaseContext()).Handle(new AddOrUpdateAccountCommand
{
Id = account.Id,
Name = model.Name,
PageUrl = homePageUrl,
FacebookId = accountFacebookId,
Password = model.Password,
Login = model.Login,
Proxy = model.Proxy,
ProxyLogin = model.ProxyLogin,
ProxyPassword = model.ProxyPassword
});
return(accountId);
}
var modelForJob = new AddOrUpdateAccountModel
{
Account = new AccountViewModel
{
Id = accountId,
PageUrl = account.PageUrl,
Login = account.Login,
Password = account.Password,
FacebookId = account.FacebookId,
Proxy = account.Proxy,
ProxyLogin = account.ProxyLogin,
ProxyPassword = account.ProxyPassword,
Cookie = account.Cookie.CookieString,
Name = model.Name,
GroupSettingsId = account.GroupSettingsId,
AuthorizationDataIsFailed = account.AuthorizationDataIsFailed,
ProxyDataIsFailed = account.ProxyDataIsFailed,
ConformationDataIsFailed = account.ConformationIsFailed,
IsDeleted = account.IsDeleted,
UserAgentId = account.UserAgentId
}
};
_jobService.AddOrUpdateAccountJobs(modelForJob);
return(accountId);
}
public void AddOrUpdateSpyAccount(SpyAccountViewModel model, IBackgroundJobService backgroundJobService)
{
var accountId = new AddOrUpdateSpyAccountCommandHandler(new DataBaseContext()).Handle(new AddOrUpdateSpyAccountCommand
{
Id = model.Id,
Name = model.Name,
PageUrl = model.PageUrl,
FacebookId = model.FacebookId,
Password = model.Password,
Login = model.Login,
Proxy = model.Proxy,
ProxyLogin = model.ProxyLogin,
ProxyPassword = model.ProxyPassword
});
new CookieService().RefreshCookies(new AccountViewModel
{
Id = accountId,
Login = model.Login,
Password = model.Password,
Proxy = model.Proxy,
ProxyLogin = model.ProxyLogin,
ProxyPassword = model.ProxyPassword,
},
true,
backgroundJobService);
var account = new GetSpyAccountByIdQueryHandler(new DataBaseContext()).Handle(new GetSpyAccountByIdQuery
{
UserId = accountId
});
if (model.PageUrl == null || model.FacebookId == 0)
{
var accountFacebookId = _proxyManager.GetAccountFacebookId(account.Cookie.CookieString);
var homePageUrl = _accountManager.CreateHomePageUrl(accountFacebookId);
new AddOrUpdateSpyAccountCommandHandler(new DataBaseContext()).Handle(new AddOrUpdateSpyAccountCommand
{
Id = account.Id,
Name = model.Name,
PageUrl = homePageUrl,
FacebookId = accountFacebookId,
Password = model.Password,
Login = model.Login,
Proxy = model.Proxy,
ProxyLogin = model.ProxyLogin,
ProxyPassword = model.ProxyPassword
});
account = new GetSpyAccountByIdQueryHandler(new DataBaseContext()).Handle(new GetSpyAccountByIdQuery
{
UserId = accountId
});
}
var jobModel = new AddOrUpdateAccountModel
{
Account = new AccountViewModel
{
Id = accountId,
Name = model.Name,
PageUrl = model.PageUrl,
FacebookId = account.FacebookId,
Password = model.Password,
Login = model.Login,
Proxy = model.Proxy,
ProxyLogin = model.ProxyLogin,
ProxyPassword = model.ProxyPassword,
Cookie = account.Cookie.CookieString
}
};
_jobService.AddOrUpdateSpyAccountJobs(jobModel);
}
public TimerFunctions(IBackgroundJobService backgroundJobService, IWebhookService webhookService)
{
_backgroundJobService = backgroundJobService;
_webhookService = webhookService;
}
public bool RefreshCookies(AccountViewModel account, bool forSpy, IBackgroundJobService backgroundJob)
{
if (account.Proxy != null)
{
var proxyIsFailed = new CheckProxyEngine().Execute(new CheckProxyModel
{
Driver = _seleniumManager.RegisterNewDriver(account)
});
if (proxyIsFailed)
{
if (forSpy)
{
new UpdateFailSpyAccountInformationCommandHandler(new DataBaseContext()).Handle(
new UpdateFailSpyAccountInformationCommand
{
AccountId = account.Id,
ProxyDataIsFailed = true
});
}
else
{
new UpdateFailAccountInformationCommandHandler(new DataBaseContext()).Handle(
new UpdateFailAccountInformationCommand
{
AccountId = account.Id,
ProxyDataIsFailed = true
});
}
backgroundJob.RemoveAllBackgroundJobs(new RemoveAccountJobsModel
{
AccountId = account.Id,
IsForSpy = forSpy,
Login = account.Login
});
return(false);
}
}
var cookieResponse = new GetNewCookiesEngine().Execute(new GetNewCookiesModel
{
Login = account.Login,
Password = account.Password,
Driver = _seleniumManager.RegisterNewDriver(account),
Cookie = account.Cookie
});
if (cookieResponse == null || cookieResponse.AuthorizationError)
{
if (forSpy)
{
new UpdateFailSpyAccountInformationCommandHandler(new DataBaseContext()).Handle(
new UpdateFailSpyAccountInformationCommand
{
AccountId = account.Id,
AuthorizationDataIsFailed = true
});
}
else
{
new UpdateFailAccountInformationCommandHandler(new DataBaseContext()).Handle(
new UpdateFailAccountInformationCommand
{
AccountId = account.Id,
AuthorizationDataIsFailed = true
});
}
backgroundJob.RemoveAllBackgroundJobs(new RemoveAccountJobsModel
{
AccountId = account.Id,
IsForSpy = forSpy,
Login = account.Login
});
return(false);
}
if (cookieResponse.ConfirmationError)
{
if (forSpy)
{
new UpdateFailSpyAccountInformationCommandHandler(new DataBaseContext()).Handle(
new UpdateFailSpyAccountInformationCommand
{
AccountId = account.Id,
ConformationIsFailed = true
});
}
else
{
new UpdateFailAccountInformationCommandHandler(new DataBaseContext()).Handle(
new UpdateFailAccountInformationCommand
{
AccountId = account.Id,
ConformationIsFailed = true
});
}
backgroundJob.RemoveAllBackgroundJobs(new RemoveAccountJobsModel
{
AccountId = account.Id,
IsForSpy = forSpy,
Login = account.Login
});
return(false);
}
var newCookie = cookieResponse.CookiesString;
if (newCookie == null)
{
return(false);
}
if (forSpy)
{
new UpdateCookiesForSpyHandler(new DataBaseContext()).Handle(new UpdateCookiesForSpyCommand
{
AccountId = account.Id,
NewCookieString = newCookie
});
}
else
{
new UpdateCookiesHandler(new DataBaseContext()).Handle(new UpdateCookiesCommand()
{
AccountId = account.Id,
NewCookieString = newCookie
});
}
new UpdateFailSpyAccountInformationCommandHandler(new DataBaseContext()).Handle(
new UpdateFailSpyAccountInformationCommand
{
AccountId = account.Id,
ProxyDataIsFailed = false,
AuthorizationDataIsFailed = false,
ConformationIsFailed = false
});
return(true);
}
public FolderManager(AppDbContext db, IMapper mapper, IBackgroundJobService jobSvc)
{
_db = db;
_mapper = mapper;
_jobSvc = jobSvc;
}
public void SaveGroupFunctions(long groupId, List <long> funtions, IBackgroundJobService backgroundJobService)
{
var functionsIdForRun = new List <FunctionName>();
var oldFuntions =
new GetGroupFunctionsByGroupIdQueryHandler(new DataBaseContext()).Handle(new GetGroupFunctionsByGroupIdQuery
{
GroupId = groupId
});
new SaveGroupFunctionsCommandHandler(new DataBaseContext()).Handle(new SaveGroupFunctionsCommand
{
GroupId = groupId,
Functions = funtions
});
var newFunctions =
new GetGroupFunctionsByGroupIdQueryHandler(new DataBaseContext()).Handle(new GetGroupFunctionsByGroupIdQuery
{
GroupId = groupId
});
foreach (var funtion in newFunctions)
{
if (oldFuntions.Any(data => data.FunctionId == funtion.FunctionId))
{
continue;
}
if (oldFuntions.All(data => data.FunctionId != funtion.FunctionId))
{
functionsIdForRun.Add(funtion.FunctionName);
}
}
var accounts =
new GetAccountsByGroupSettingsIdQueryHandler(new DataBaseContext()).Handle(new GetAccountsByGroupSettingsIdQuery
{
GroupSettingsId = groupId
});
var accountsViewModel = accounts.Select(model => new AccountViewModel
{
Id = model.Id,
PageUrl = model.PageUrl,
Login = model.Login,
Password = model.Password,
FacebookId = model.FacebookId,
Proxy = model.Proxy,
ProxyLogin = model.ProxyLogin,
ProxyPassword = model.ProxyPassword,
Cookie = model.Cookie.CookieString,
Name = model.Name,
GroupSettingsId = model.GroupSettingsId,
AuthorizationDataIsFailed = model.AuthorizationDataIsFailed,
ProxyDataIsFailed = model.ProxyDataIsFailed,
IsDeleted = model.IsDeleted,
UserAgentId = model.UserAgentId
}).ToList();
foreach (var accountModel in accountsViewModel)
{
//удаляем выключенные задачи
foreach (var oldFuntion in oldFuntions)
{
if (newFunctions.All(data => data.FunctionId != oldFuntion.FunctionId))
{
var stateList = _jobStateService.GetStatesByAccountAndFunctionName(new JobStateViewModel
{
AccountId = accountModel.Id,
FunctionName = oldFuntion.FunctionName,
IsForSpy = false
});
foreach (var state in stateList)
{
_jobStateService.DeleteJobState(state);
backgroundJobService.RemoveBackgroundJobById(state.JobId);
}
}
}
foreach (var function in functionsIdForRun)
{
var delayTime = _settingsManager.GetTimeSpanByFunctionName(function, groupId);
var model = new CreateBackgroundJobModel
{
Account = accountModel,
CheckPermissions = true,
FunctionName = function,
LaunchTime = delayTime
};
backgroundJobService.CreateBackgroundJob(model);
}
}
}
public CustomerUpdatedEventHandler(IDbContext dbContext, IBackgroundJobService backgroundJobService)
{
_dbContext = dbContext;
_backgroundJobService = backgroundJobService;
}
public void UpdateSettings(GroupSettingsViewModel newSettings, IBackgroundJobService backgroundJobService)
{
var oldSettings = _accountSettingsManager.GetSettings(newSettings.GroupId);
var winkOptions = new WinkFriendsOptionsDbModel
{
RetryTimeForWinkFriends = new TimeModel
{
Hours = newSettings.RetryTimeForWinkFriendsHour,
Minutes = newSettings.RetryTimeForWinkFriendsMin,
Seconds = newSettings.RetryTimeForWinkFriendsSec
},
ConsiderGeoForWinkFriends = newSettings.ConsiderGeoForWinkFriends,
RetryTimeForWinkFriendsFriends = new TimeModel
{
Hours = newSettings.RetryTimeForWinkFriendsFriendsHour,
Minutes = newSettings.RetryTimeForWinkFriendsFriendsMin,
Seconds = newSettings.RetryTimeForWinkFriendsFriendsSec
},
ConsiderGeoForWinkFriendsFriends = newSettings.ConsiderGeoForWinkFriendsFriends,
RetryTimeForWinkBack = new TimeModel
{
Hours = newSettings.RetryTimeForWinkBackHour,
Minutes = newSettings.RetryTimeForWinkBackMin,
Seconds = newSettings.RetryTimeForWinkBackSec
},
};
var communityOptions = new CommunityOptionsDbModel
{
Groups = ConvertStringToList(newSettings.FacebookGroups),
Pages = ConvertStringToList(newSettings.FacebookPages),
IsJoinToAllGroups = newSettings.IsJoinToAllGroups,
RetryTimeInviteTheGroups = new TimeModel
{
Hours = newSettings.RetryTimeInviteTheGroupsHour,
Minutes = newSettings.RetryTimeInviteTheGroupsMin,
Seconds = newSettings.RetryTimeInviteTheGroupsSec
},
RetryTimeInviteThePages = new TimeModel
{
Hours = newSettings.RetryTimeInviteThePagesHour,
Minutes = newSettings.RetryTimeInviteThePagesMin,
Seconds = newSettings.RetryTimeInviteThePagesSec
},
MaxFriendsJoinGroupInDay = newSettings.MaxFriendsJoinGroupInDay,
MinFriendsJoinGroupInDay = newSettings.MinFriendsJoinGroupInDay,
MaxFriendsJoinGroupInHour = newSettings.MaxFriendsJoinGroupInHour,
MinFriendsJoinGroupInHour = newSettings.MinFriendsJoinGroupInHour,
MaxFriendsJoinPageInDay = newSettings.MaxFriendsJoinPageInDay,
MinFriendsJoinPageInDay = newSettings.MinFriendsJoinPageInDay,
MaxFriendsJoinPageInHour = newSettings.MaxFriendsJoinPageInHour,
MinFriendsJoinPageInHour = newSettings.MinFriendsJoinPageInHour,
};
var geoOptions = new GeoOptionsDbModel
{
Cities = string.IsNullOrEmpty(newSettings.Cities) ? string.Empty : newSettings.Cities,
Countries = string.IsNullOrEmpty(newSettings.Countries) ? string.Empty : newSettings.Countries,
Gender = newSettings.Gender
};
var friendsOptions = new FriendOptionsDbModel
{
RetryTimeConfirmFriendships = new TimeModel
{
Hours = newSettings.RetryTimeConfirmFriendshipsHour,
Minutes = newSettings.RetryTimeConfirmFriendshipsMin,
Seconds = newSettings.RetryTimeConfirmFriendshipsSec
},
RetryTimeGetNewAndRecommendedFriends = new TimeModel
{
Hours = newSettings.RetryTimeGetNewAndRecommendedFriendsHour,
Minutes = newSettings.RetryTimeGetNewAndRecommendedFriendsMin,
Seconds = newSettings.RetryTimeGetNewAndRecommendedFriendsSec
},
RetryTimeRefreshFriends = new TimeModel
{
Hours = newSettings.RetryTimeRefreshFriendsHour,
Minutes = newSettings.RetryTimeRefreshFriendsMin,
Seconds = newSettings.RetryTimeRefreshFriendsSec
},
RetryTimeSendRequestFriendships = new TimeModel
{
Hours = newSettings.RetryTimeSendRequestFriendshipsHour,
Minutes = newSettings.RetryTimeSendRequestFriendshipsMin,
Seconds = newSettings.RetryTimeSendRequestFriendshipsSec
},
AllowedRemovalPercentage = newSettings.AllowedRemovalPercentage
};
var messageOptions = new MessageOptionsDbModel
{
GetMessagesFromThoseConnectedToMessenger = newSettings.GetMessagesFromThoseConnectedToMessenger,
RetryTimeSendNewFriend = new TimeModel
{
Hours = newSettings.RetryTimeSendNewFriendHour,
Minutes = newSettings.RetryTimeSendNewFriendMin,
Seconds = newSettings.RetryTimeSendNewFriendSec
},
RetryTimeSendUnanswered = new TimeModel
{
Hours = newSettings.RetryTimeSendUnansweredHour,
Minutes = newSettings.RetryTimeSendUnansweredMin,
Seconds = newSettings.RetryTimeSendUnansweredSec
},
RetryTimeSendUnread = new TimeModel
{
Hours = newSettings.RetryTimeSendUnreadHour,
Minutes = newSettings.RetryTimeSendUnreadMin,
Seconds = newSettings.RetryTimeSendUnreadSec
},
UnansweredDelay = newSettings.UnansweredDelay
};
var limitsOptions = new LimitsOptionsDbModel
{
CountMaxFriends = newSettings.CountMaxFriends,
CountMinFriends = newSettings.CountMinFriends
};
var deleteFriendsOptions = new DeleteFriendsOptionsDbModel
{
DialogIsOver = new DialogIsOverModel
{
IsEnabled = newSettings.EnableDialogIsOver,
Timer = newSettings.DialogIsOverTimer
},
IsAddedToGroupsAndPages = new IsAddedToGroupsAndPagesModel
{
IsEnabled = newSettings.EnableIsAddedToGroupsAndPages,
Timer = newSettings.IsAddedToGroupsAndPagesTimer
},
IsWink = new IsWinkModel
{
IsEnabled = newSettings.EnableIsWink,
Timer = newSettings.IsWinkTimer
},
IsWinkFriendsOfFriends = new IsWinkFriendsOfFriendsModel
{
IsEnabled = newSettings.EnableIsWinkFriendsOfFriends,
Timer = newSettings.IsWinkFriendsOfFriendsTimer
},
DeletionFriendTimer = newSettings.DeletionFriendTimer
};
var command = new AddOrUpdateSettingsCommand
{
GroupId = newSettings.GroupId,
GeoOptions = geoOptions,
FriendsOptions = friendsOptions,
MessageOptions = messageOptions,
LimitsOptions = limitsOptions,
CommunityOptions = communityOptions,
DeleteFriendsOptions = deleteFriendsOptions,
WinkFriendsOptions = winkOptions
};
new AddOrUpdateSettingsCommandHandler(new DataBaseContext()).Handle(command);
var accountsThisGroup =
new GetAccountsByGroupSettingsIdQueryHandler(new DataBaseContext()).Handle(
new GetAccountsByGroupSettingsIdQuery
{
GroupSettingsId = newSettings.GroupId
});
var accountsViewModel = accountsThisGroup.Select(model => new AccountViewModel
{
Id = model.Id,
PageUrl = model.PageUrl,
Login = model.Login,
Password = model.Password,
FacebookId = model.FacebookId,
Proxy = model.Proxy,
ProxyLogin = model.ProxyLogin,
ProxyPassword = model.ProxyPassword,
Cookie = model.Cookie.CookieString,
Name = model.Name,
GroupSettingsId = model.GroupSettingsId,
AuthorizationDataIsFailed = model.AuthorizationDataIsFailed,
ProxyDataIsFailed = model.ProxyDataIsFailed,
IsDeleted = model.IsDeleted,
UserAgentId = model.UserAgentId
}).ToList();
var modelNewData = GetNewGroupsAndPages(communityOptions, oldSettings);
foreach (var accountModel in accountsViewModel)
{
if (modelNewData != null)
{
if (modelNewData.Groups.Count != 0 || modelNewData.Pages.Count != 0)
{
new SaveNewSettingsCommandHandler(new DataBaseContext()).Handle(new SaveNewSettingsCommand
{
AccountId = accountModel.Id,
CommunityOptions = modelNewData,
GroupId = newSettings.GroupId
});
}
}
var model = accountModel;
var updater = new Task(() => UpdateJobsTask(backgroundJobService, model, newSettings, oldSettings));
updater.Start();
}
}
