public SendReportCommand(IAntiplagiatService antiplagiatService, IVkApi vkApi, MireaAntiplagiatDataContext context)
{
this.vkApi = vkApi;
this.context = context;
this.antiplagiatService = antiplagiatService;
antiplagiatService.OnDocumentChecked += AntiplagiatService_OnDocumentChecked;
}
static void Main(string[] args)
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <IBrowser, Authorization>();
serviceCollection.AddSingleton <IRestClient, RestClientEx>();
serviceCollection.AddSingleton <IReceiptParser, ReceiptParser>();
_api = new VkApi(serviceCollection);
_api.Authorize(new ApiAuthParams
{
Login = "******",
Password = "******"
});
var audios = _api.Audio.Get(out var user, new AudioGetParams {
Count = 10
});
foreach (var audio in audios)
{
Console.WriteLine($" > {audio.Artist} - {audio.Title}");
}
Console.ReadLine();
}
public MessageController(IVkApi vkApi)
{
_vkApi = vkApi;
_controller = new VkBotController();
_anekManager = new AnekManager(_controller);
_sender = new MessageSender(_vkApi);
}
public messageObjectHandlers(IVkApi _vkApi, string Object)
{
this._vkApi = _vkApi;
Dictionary <string, object> messageObject = JsonSerializer.Deserialize <Dictionary <string, object> >(Object);
if (queues == null)
{
queues = new Dictionary <string, Queue>();
}
if (!messageObject.ContainsKey("message"))
{
return;
}
Dictionary <string, object> message = JsonSerializer.Deserialize <Dictionary <string, object> >(messageObject["message"].ToString());
if (!message.ContainsKey("text"))
{
return;
}
if (!message.ContainsKey("peer_id"))
{
return;
}
string messageText = message["text"].ToString();
if (!messageText.StartsWith("[club203355401|"))
{
return;
}
messageText = messageText.Substring(messageText.IndexOf(']') + 1);
if (messageText.Contains("старт") && message.ContainsKey("from_id") && message["from_id"].ToString() == "194465804")
{
messageText = StartQueue(messageText);
}
else if (messageText.Contains("стоп") && message.ContainsKey("from_id") && message["from_id"].ToString() == "194465804")
{
messageText = StopQueue(messageText);
}
else if (messageText.Contains("запись"))
{
messageText = AddQueue(messageText, (message.ContainsKey("from_id")) ? message["from_id"].ToString() : "");
}
else if (messageText.Contains("отписаться"))
{
messageText = RemoveQueue(messageText, (message.ContainsKey("from_id")) ? message["from_id"].ToString() : "");
}
else if (messageText.Contains("очередь"))
{
messageText = StatusQueue(messageText);
}
else
{
messageText = "Чего хотел?";
}
SendMessage(long.Parse(message["peer_id"].ToString()), messageText);
}
public void SetUp()
{
_api = Mock.Of <IVkApi>();
_wall = Mock.Of <IWallCategory>();
Mock.Get(_api)
.Setup(x => x.Wall)
.Returns(() => _wall);
Mock.Get(_wall)
.Setup(x => x.Post(It.IsAny <WallPostParams>()))
.Returns(() => PostId);
var posts = new List <Post>
{
CreateSomePost(),
CreateSomePost(),
CreateSomePost(),
CreateSomePost(),
CreateSomePost()
};
Mock.Get(_wall)
.Setup(x => x.Get(It.IsAny <WallGetParams>(), It.IsAny <bool>()))
.Returns(() => new WallGetObject {
WallPosts = new ReadOnlyCollection <Post>(posts)
});
CreateSomePost();
_log = Mock.Of <ILog>();
_sut = new LetterStatsReporter(_api, _log);
}
public async Task <ActionResult> Generate(DrawingRequest request, IVkApi vkApi)
{
var notparseIds = request.Post.Split(new [] { "wall" }, StringSplitOptions.None)[1];
var ids = notparseIds.Split('_');
int ownerid;
int postid;
if (!int.TryParse(ids[0], out ownerid))
{
return(BadRequest());
}
if (!int.TryParse(ids[1], out postid))
{
return(BadRequest());
}
var reposts = await vkApi.GetReposts(ownerid, postid);
var peoples = new List <string>();
for (int i = 0; i < request.Count; i++)
{
}
return(View());
}
public CommandHandler(MainContext db, IVkApi vkApi, CommandExecutor commandExecutor, RolesHandler checker)
{
_db = db;
_vkApi = vkApi;
_commandExecutor = commandExecutor;
_checker = checker;
}
public Result TryAuthorize(IVkApi vkApi, string login, string password)
{
try
{
if (!vkApi.IsAuthorized)
{
if (string.IsNullOrEmpty(login) || string.IsNullOrEmpty(password))
{
return(Result.Error(
"Пользователь не авторизован, пожалуйста, вызовите команду с соответствующими параметрам (логином и паролем)"));
}
vkApi.Authorize(new ApiAuthParams
{
ApplicationId = 6952669,
Login = login,
Password = password,
Settings = Settings.Wall | Settings.Groups,
TwoFactorAuthorization = twoFactorAuthorization
});
}
}
catch (VkApiException e)
{
log.Error("User cannot be authorized.", e);
return(Result.Error("Не удалось авторизоваться, возможно введен неверный логин или пароль."));
}
return(Result.Success());
}
public void GetAuth(string login = null, string password = null)
{
vkDatas.service = new ServiceCollection();
vkDatas.service.AddAudioBypass();
api = new VkApi(vkDatas.service);
if (Token != null)
{
AuthToken();
}
else
{
try
{
Auth2Fact(login, password);
if (!api.IsAuthorized)
{
AuthLogPass(login, password);
}
}
catch
{
MessageBox.Show("Неверный логин или пароль", "Ошибка", MessageBoxButtons.OK);
}
}
rnd = new Random();
isAuth = true;
}
public async Task Logout()
{
_api = new VkApi();
await _tokenStorage.WriteToken <VkontakteFileSystemProvider>(null);
_isAuthorized.OnNext(_api.IsAuthorized);
}
private async Task RunAsync()
{
_api = await VkLogin.SimpleLoginAndGetApi(_app, _login, _pas, VkScope.Friends);
var resolver = new Antigate(_antigate);
var items = new List <GroupFriendsFileLine>(File.ReadAllLines(_in).Select(_ => new GroupFriendsFileLine(_)));
var current = 0;
foreach (var item in items.Where(_ => _.State == State.Wait))
{
try
{
var res = await _api.Friends.Add(resolver, item.UserId, _message);
switch (res)
{
case VkAddFriendsResultEnum.SuccessRequest:
item.State = State.SuccessRequest;
current++;
break;
case VkAddFriendsResultEnum.SucessAdd:
item.State = State.SuccessAdd;
current++;
break;
case VkAddFriendsResultEnum.AlreadyRequest:
item.State = State.AlreadyExist;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
catch (Exception ex)
{
Logger.ErrorException("add friend exception", ex);
item.Comment = ex.Message.Replace('\n', ' ').Replace('|', ' ');
item.State = State.Error;
}
item.Comment += " Complete:" + DateTime.Now.ToLongDateString();
if (current >= _count)
{
break;
}
}
if (File.Exists(_out))
{
File.Delete(_out);
}
using (var outFile = new StreamWriter(File.OpenWrite(_out)))
{
foreach (var item in items)
{
outFile.WriteLine(item.Serialize());
}
}
}
/// <summary>
/// Инициализирует новый экземпляр класса <see cref="MenuBase"/>. Для его создания в контейнере зависимостей необходимо зарегистрировать <see cref="IVkApi"/> и <see cref="ICommandManager"/>.
/// </summary>
/// <param name="peerId">Идентификатор чата, в котором работает меню.</param>
/// <param name="vkApi">API-ВКонтакте</param>
protected MenuBase(long peerId, IVkApi vkApi)
{
PeerId = peerId;
_vkApi = vkApi;
MenuText = string.Join('\n',
CommonHelper.ExtractMethodsWithAttribute <CommandMenuItemAttribute>(GetType()).Select(p => p.Key.DisplayText));
}
public CallbackController(IVkApi _vkApi, IConfiguration configuration)
{
this.configuration = configuration;
vkApi = _vkApi;
tasker = new Tasker(vkApi);
Tasker.allUsers = Tasker.OpenAll(); //Открывем файл с данными пользователей.
}
public async Task StartWatchAsync(IVkApi api, WallWatchModel model)
{
if (!IsActive)
{
IsActive = true;
_api = api;
_model = model;
_logger?.LogTrace($"Starting wall watcher for {ApiTargetDescriptor()}");
_longCheckPeriod = _model.MonitoringPeriod;
_shortCheckPeriod = _model.ShortMonitoringPeriod;
// Do maximum coverage check first
await ProcessWallWatch(TypesOfChecking.Long);
_nextLongCheck = DateTime.UtcNow + model.MonitoringPeriod;
_nextShortCheck = DateTime.UtcNow + model.ShortMonitoringPeriod;
if (IsActive)
{
_wallWatchTimer = new Timer(WatchStepAsync, null,
dueTime: Convert.ToInt32(_model.ShortMonitoringPeriod.TotalMilliseconds),
period: Timeout.Infinite);
}
}
else
{
_logger?.Log(LogLevel.Trace, $"Attemption to start active watcher for {ApiTargetDescriptor()}.");
}
}
public async Task <VkNewsfeedResult> ExtractAsync(ILogger logger, IVkApi api, ProviderSettings providerSettings, State state, EndpointOptions endpointOptions, CancellationToken cancellationToken)
{
VkNewsFeedGetResponse apiResult;
string startFrom = null;
var extractedProfiles = new List <Profile>();
var extractedItems = new List <ResponseItem>();
do
{
apiResult = await GetVkFeedAsync(api, providerSettings.AccessToken, startFrom, cancellationToken);
logger.LogDebug($"{nameof(GetVkFeedAsync)} result: {apiResult.Response.Items.Count} items, NextFrom = {apiResult.Response.NextFrom}");
startFrom = apiResult.Response.NextFrom;
extractedProfiles.AddRange(apiResult.Response.Profiles);
extractedItems.AddRange(apiResult.Response.Items);
} while (!string.IsNullOrWhiteSpace(startFrom) &&
(state.LastRecordCreatedUtc == null || apiResult.AreAllItemsNewerThan(state.LastRecordCreatedUtc.Value)) &&
(endpointOptions.MaxDaysFromNow == null || endpointOptions.MaxDaysFromNow == 0 || apiResult.AreAllItemsNewerThan(DateTime.UtcNow.AddDays(endpointOptions.MaxDaysFromNow.Value * -1))));
return(new VkNewsfeedResult()
{
Profiles = extractedProfiles,
ResponseItems = extractedItems.OrderBy(ri => ri.Date).ToList()
});
}
public Task Logout()
{
_api = new VkApi();
Parameters.Token = null;
_isAuthorized.OnNext(_api.IsAuthorized);
return(Task.CompletedTask);
}
public VkProvider(ILogger <VkProvider> logger,
ILogger <VkLongPoll> pollLogger,
ILogger <VkApi> apiLogger,
IOptions <VkConfiguration> configuration)
{
_accessToken = configuration.Value.AccessToken;
_groupId = configuration.Value.GroupId;
Logger = logger;
InboundClient = new VkApi(apiLogger);
ApiClient = new VkApi(apiLogger);
_setApiVersion(5, 120);
_authorize(new ApiAuthParams
{
AccessToken = _accessToken
});
VkPoller = new VkLongPoll(InboundClient, _groupId, pollLogger);
DisplayNameCache = new LRUCache <long, string>(1000, 6);
VkPoller.OnMessageReceived += _onMessage;
}
private async Task RunAsync()
{
var groups = File.ReadAllLines(_in);
_api = await VkLogin.SimpleLoginAndGetApi(_app, _login, _pas, VkScope.Friends);
var items = new List <GroupFriendsFileLine>();
foreach (var gr in groups)
{
var arr = await GetFriends(gr);
items.AddRange(arr);
//может вызываться слишком быстро
Thread.Sleep(500);
}
if (File.Exists(_out))
{
File.Delete(_out);
}
using (var outFile = new StreamWriter(File.OpenWrite(_out)))
{
foreach (var item in items)
{
outFile.WriteLine(item.Serialize());
}
}
}
private static void Main(string[] args)
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddAudioBypass();
_api = new VkApi(serviceCollection);
_api.Authorize(new ApiAuthParams
{
Login = "******",
Password = "******",
TwoFactorAuthorization = () =>
{
Console.WriteLine(" > Введите код:");
return(Console.ReadLine());
}
});
var audios = _api.Audio.Get(new AudioGetParams {
Count = 10
});
foreach (var audio in audios)
{
Console.WriteLine($" > {audio.Artist} - {audio.Title}");
}
Console.ReadLine();
}
public CallbackController(IVkApi vkApi, IConfiguration configuration, MainContext db, MessageExecutor executor)
{
_vkApi = vkApi;
_configuration = configuration;
_db = db;
_executor = executor;
}
public VkStatTwitNotifier(IVkAuthorizer vkAuthorizer, IVkApi vkApi, ITwitStatCollector twitStatCollector, ILog log)
{
this.vkAuthorizer = vkAuthorizer;
this.vkApi = vkApi;
this.twitStatCollector = twitStatCollector;
this.log = log;
}
public override bool Execute(GroupUpdate update, IVkApi bot)
{
if (update.Type == GroupUpdateType.MessageNew &&
update.MessageNew != null &&
update.MessageNew.Message != null &&
update.MessageNew.Message.Attachments.Any())
{
var attachment = update.MessageNew.Message.Attachments.First();
if (attachment.Type == typeof(Document))
{
var document = attachment.Instance as Document;
using (var client = new WebClient())
{
string salt = Guid.NewGuid().ToString().Substring(0, 8);
string path = Path.Combine(Folders.Docs(), $"{update.MessageNew.Message.FromId} {salt} Check.{document.Ext}");
client.DownloadFile(document.Uri, path);
update.ReplyMessageNew(bot, AppData.Strings.DocumentSaved);
context.PathUserId.Add(path, (long)update.MessageNew.Message.FromId);
antiplagiatService.EnqueueDocument(path);
}
return(true);
}
}
return(false);
}
public VkUtils(IVkApi vkApi)
{
_api = vkApi;
_logger = LogManager.GetCurrentClassLogger();
_supportedVkTypes = new List <VkObjectType> {
VkObjectType.Group, VkObjectType.User
};
}
public VkEventHandler(IVkApi vkApi,
WordAndAnswerRepository wordAndAnswerRepository,
QuestionAndAnswerRepository questionAndAnswerRepository)
{
this.vkApi = vkApi;
this.wordAndAnswerRepository = wordAndAnswerRepository;
this.questionAndAnswerRepository = questionAndAnswerRepository;
}
public override string Do(IVkApi vkApi, Message message)
{
if (message.PeerId == 302383860)
{
return(message.Text.Replace("Кирилл", "Артур", true, null));
}
return($"Да. {message.Text}");
}
public StartupTasks(BotDbContext db, IOptions <MailingOptions> options, IVkApi api)
{
_db = db;
_api = api;
_options = options.Value;
InitJobsFromDatabase();
}
public ScheduleShowCommands(IVkApi api, IEventRepository eventRepository, IRegularScheduleRepository scheduleRepository,
IScheduleFormatService formatService)
{
_api = api;
_eventRepository = eventRepository;
_scheduleRepository = scheduleRepository;
_formatService = formatService;
}
/// <inheritdoc />
public TClient CreateVkApi(IVkApi vkApi)
{
if (vkApi == null)
{
throw new ArgumentNullException(nameof(vkApi));
}
return((TClient)_cache.Activator(_services, new object[] { vkApi }));
}
public BotController(ILogger <BotController> logger, IConfiguration configuration, MessageProcessing messageProcessing, IVkApi vkApi)
{
Log = logger;
Config = configuration;
CommandBinding = messageProcessing;
Vk = vkApi;
Log.LogInformation("Services Inited");
}
public Calculator(IVkApi api)
{
_client = new HttpClient
{
BaseAddress = new Uri("https://newton.now.sh/simplify/")
};
_vkApi = api;
}
