Generera Gmail-adress med C ++
Skapa din egen temp Gmail-generator med lösenord med C ++
Ladda ner gratis prövning
Gmail-generator är ett ganska vanligt sätt att hantera e-postprenumerationer. I huvudsak är detta en analog av en leverantör av tillfälliga e-postadresser, men mycket mer flexibel, pålitlig och säker.
Kärnan i generatorn är att skapa ytterligare Gmail-adresser. Du kan använda dessa ytterligare adresser när du registrerar dig på olika webbplatser. Dessa webbplatser kommer sannolikt att skicka e-post till de adresser du anger. Eftersom adresserna är ytterligare kommer alla bokstäver att gå till din huvudadress. Men samtidigt kommer en ytterligare adress som genereras av applikationen eller förberedd manuellt att anges som mottagare av brevet.
Genom att söka efter e-postmeddelanden efter mottagarens adress kan du filtrera bort e-postmeddelanden och utföra automatiska åtgärder på dem. En gång eller permanent. Du kan också fånga webbplatser som delar din adress med tredje part utan ditt samtycke.
Låt oss till exempel säga att du skapade en extra adress användarnamn+ for.spam.sender@gmail.com . Du skickade sedan det till webbplatsen spam-sender.com. Efter en tid kan du få ett e-postmeddelande från någon annan webbplats, till exempel other-sender.com, men mottagaren kommer att vara användarnamn+ for.spam.sender@gmail.com . I någon annan situation skulle du inte kunna ta reda på varför other-sender.com skickar dig reklammeddelanden, men eftersom du har använt en alternativ adress är det lätt att se att spam-sender.com har delat din adress med tredje part. Och i så fall är det ingen mening att avsluta prenumerationen från e-postlistorna på dessa webbplatser. Din ytterligare adress har antagligen redan inkluderats i någon offentlig bas för att skicka oönskade e-postmeddelanden. Det blir mycket lättare om du bara blockerar all e-post som kommer till den här ytterligare adressen. Det skulle vara ännu bättre om du ställer in automatisk förflyttning av sådana e-postmeddelanden till skräppostmappen. Denna inställning kommer att göra livet mycket svårt för dessa webbplatser eftersom Gmail vet att dessa webbplatser skickar skräppost.
Så låt oss ta reda på hur man implementerar en sådan generator med Aspose.Email för C ++.
Generera temp Gmail och arbeta med det
För att generera en extra Gmail-adress behöver vi faktiskt inte Aspose.Email, vi behöver inte interagera med Gmail-tjänsten på något sätt. Varje ytterligare adress som du skapar manuellt eller slumpmässigt, med förbehåll för vissa regler, kommer att fungera.
Så vad är dessa regler?
Poängen är inte viktiga. Det vill säga, i din adress, före symbolen ”@”, kan du både ta bort prickar och lägga till nya mellan några par bokstäver.
Innan ”@” -tecknet kan du lägga till ett ”+” -tecken med valfri uppsättning bokstäver och siffror efter det. Exempel på adressen ”username@gmail.com”:
Alla dessa adresser kan redan användas vid registrering på webbplatser. Men på egen hand är de lite meningsfulla, eftersom alla meddelanden som kommer till dessa adresser kommer att hamna i din huvudbrevlåda. Därför är det värt att använda våra instruktioner för att arbeta med dessa adresser.
Enkel temp Gmail-generator
Så låt oss skapa en enkel slumpmässig underadressgenerator. För att göra detta lägger vi till en slumpmässig sträng mellan tecknen ‘+’ och ‘@’. Först och främst måste vi generera en slumpmässig sträng av en viss längd, bestående av en viss uppsättning tecken:
const char16_t pattern[] = u"abcdefghijklmnopqrstuvwxyz0123456789";
auto patternLength = std::char_traits<char16_t>::length(pattern);
const int suffixLength = 10;
std::string generatedSuffix;
generatedSuffix.reserve(suffixLength);
srand(time(NULL));
for (int i = 0; i < suffixLength; i++)
{
generatedSuffix += pattern[rand() % (patternLength - 1)];
}
Nu måste vi få e-postadressen och lägga till den genererade slumpmässiga strängen till den. För att göra detta kommer vi att använda MailAdress klass från biblioteket Aspose.Email för C ++:
auto originalAddress = System::MakeObject<MailAddress>(System::String(u"some.address@gmail.com"));
auto generatedAddress = System::MakeObject<MailAddress>(
originalAddress->get_User() + u"+" + generatedSuffix + u"@" + originalAddress->get_Host());
Console::WriteLine(generatedAddress);
Klar! Den mottagna adressen kan redan användas vid registrering på webbplatser. Webbplatser kommer snart att börja skicka meddelanden till den här adressen. Låt oss se vad vi kan göra med dessa meddelanden.
Använd IMAP-klienten för att hantera meddelanden som tas emot till den genererade Gmail
För det första måste vi ansluta till Gmail för att kunna använda meddelanden som tas emot på en extra adress. IMAP är väl lämpad för detta. För att ansluta med det här protokollet, glöm inte att ställa in ditt konto för att tillåta anslutning till det med det här protokollet. Du kan också förenkla IMAP-anslutningen med ett dedikerat programlösenord. Detta gör att du kan undvika behovet av att utföra OAuth-auktorisering om du inte vill implementera det i din applikation. Gå bara till dina Google-kontoinställningar, öppna avsnittet Säkerhet och lägg till ett applösenord. Glöm inte att spara det genererade lösenordet i säker lagring och försök att inte förlora det, eftersom det ger dig full tillgång till din e-post!
Så, låt oss använda ImapClient Klass och anslut till ditt Gmail-konto med IMAP-protokollet:
auto imapClient = System::MakeObject<Clients::Imap::ImapClient>(
u"imap.gmail.com", 993, originalAddress->get_User(), u"password",
SecurityOptions::SSLAuto);
Klar, nu kan vi till exempel få alla meddelanden som tas emot på den genererade Gmail-adressen:
imapClient->SelectFolder(u"INBOX");
auto queryBuilder = System::MakeObject<ImapQueryBuilder>();
queryBuilder->get_To()->Contains(generatedAddress->get_Address());
auto list = imapClient->ListMessages(queryBuilder->GetQuery());
Och du kommer att få absolut alla sådana brev. Det spelar ingen roll vilken webbplats de kom till dig från. De kunde ha kommit från webbplatsen som du gav den genererade e-postadressen till. Kunde ha kommit från en annan plats. Från vilken adress som helst. Vi screenar e-postmeddelanden inte av avsändaren, utan av mottagaren. Och det är väldigt bekvämt.
Markera, ta bort, flytta mottagna meddelanden till den temporära Gmail
Efter att ha fått listan över brev kan vi redan utföra olika operationer på den. Framför allt på en gång. Du behöver inte hitta dem i din brevlåda en efter en. Bokstavligen markeras ett par kommandon och alla bokstäver som lästa, flyttas till en annan mapp eller helt enkelt raderas. Glöm inte att kontrollera i förväg att listan med bokstäver inte är tom. Du kanske redan har tagit bort allt.
if (list->get_Count() > 0)
{
//Mark as read
imapClient->AddMessageFlags(list, ImapMessageFlags::get_IsRead());
//Move
imapClient->MoveMessages(list, u"DestinationFolder");
//Remove
imapClient->DeleteMessages(list, true);
}
Klar, din inkorg har rensats från skräppost.
Prenumerera på tillfällig Gmail-adress
Så vad händer om du inte ständigt vill ta bort eller flagga e-postmeddelanden genom att manuellt ringa koden ovan? Vad händer om du vill ta bort e-postmeddelanden så snart de tas emot? För att göra detta kan du till exempel prenumerera på nya meddelanden och skriva en funktion som raderar meddelanden så snart de kommer till din e-postadress.
std::function<void(System::SharedPtr<System::Object> sender, System::SharedPtr<Clients::Imap::ImapMonitoringEventArgs> eventArgs)> subscribeCallback =
[&generatedAddress, &imapClient](System::SharedPtr<System::Object> sender, System::SharedPtr<ImapMonitoringEventArgs> eventArgs)
{
auto newMessages = eventArgs->get_NewMessages();
auto generated = System::MakeObject<ImapMessageInfoCollection>();
for each (auto newMessage in newMessages)
{
for each (auto address in newMessage->get_To())
{
if (address->get_Address() == generatedAddress->get_Address())
{
generated->Add(newMessage);
break;
}
}
}
if (generated->get_Count() == 0) return;
imapClient->SelectFolder(u"INBOX");
//Do something with the received messages. For example, mark them as read:
imapClient->AddMessageFlags(generated, ImapMessageFlags::get_IsRead());
//or delete them
imapClient->DeleteMessages(generated, true);
};
std::function<void(System::SharedPtr<System::Object> sender, System::SharedPtr<Clients::Imap::ImapMonitoringErrorEventArgs> eventArgs)> errorCallback =
[](System::SharedPtr<System::Object> _, System::SharedPtr<ImapMonitoringErrorEventArgs> errorEventArgs)
{
Console::WriteLine(errorEventArgs->get_Error()->get_Message());
};
imapClient->StartMonitoring(subscribeCallback, errorCallback, u"INBOX");
Denna algoritm är något förenklad eftersom prenumerationen på nya meddelanden avbryts i händelse av ett fel. Du kan förbättra algoritmen kraftigt. För att göra detta måste du förfina algoritmen genom att förbättra felhanteringen. Du kan till exempel ställa in återupptagandet av övervakningen i händelse av ett fel, för detta kan du använda funktionen IMAPClient.ResumeMonitoring. Den här funktionen återupprättar en anslutning till IMAP-servern och återupptar övervakningen för nya meddelanden.
Tyvärr, för att kunna använda denna algoritm, måste du hålla programmet ständigt igång ändå. Så snart du avbryter körningen av programmet kommer nya bokstäver inte längre att raderas automatiskt. Men i det här fallet finns det en annan lösning.
Sluta ta emot meddelanden till den genererade Gmail-adressen
Gmail tillhandahåller algoritmer för filtrering av inkommande meddelanden. Dessa algoritmer fungerar på servicesidan och släpper aldrig igenom oönskad e-post, om du naturligtvis konfigurerar dem korrekt. För närvarande kan vi tyvärr inte ge dig funktionaliteten att fjärrkonfigurera sådana filter med C ++, men vi planerar att lägga till en sådan möjlighet inom en snar framtid. Följ våra uppdateringar!
Så om du vill filtrera meddelanden som kommer in i den genererade Gmail måste du först skapa en sökmall för filtret. Här är den enklaste koden för att få mallen:
//Generate Gmail search pattern
auto searchPattern = System::String(u"to:(") + generatedAddress->get_Address() + u")";
Console::WriteLine(searchPattern);
Här är variabeln generatedAddress innehåller den genererade Gmail som skapades tidigare i den här artikeln. Ovanstående kod skapar en sökmall och skriver ut den till terminalen. Kopiera den här mallen eftersom du behöver den när du skapar filtret.
Låt oss nu beskriva steg för steg hur du kan skapa ett filter. För att komma igång, öppna Gmail-e-postwebbgränssnittet, det är tillgängligt på länken. I det här gränssnittet hittar du sökfältet:
I det här sökfältet måste du infoga mallen som genererades tidigare i den här instruktionen. Därefter måste du klicka på knappen ”Visa sökalternativ”, som anges i skärmdumpen nedan:
I fönstret sökalternativ som öppnas behöver du inte ange ytterligare data, den genererade mallen har redan konfigurerat sökningen. Klicka bara på knappen ”Skapa filter”.
Som ett resultat öppnas fönstret för filterinställningar:
Här kan du välja vad filtret ska göra med e-postmeddelanden som tas emot på den genererade Gmail-adressen. Du kan automatiskt arkivera dem, markera dem som lästa, ta bort dem och så vidare. Som regel är det bästa alternativet att ta bort e-postmeddelanden. Brevlådans volym är begränsad, det är ingen mening att spendera den på soplagring. När du har valt de åtgärder som passar dig klickar du på knappen ”Skapa filter” igen.
Klar! Filtret är fullt konfigurerat, så ingen mer skräppost kommer att störa dig.
Hantera temporära Gmail-filter
Ibland blir meddelanden som du får från en viss webbplats oönskade. De blir bara skräp i din brevlåda och hindrar dig från att hitta i det vad som verkligen är viktigt och intressant för dig. Som ett resultat skapar du ett filter som blockerar oönskade meddelanden från den här webbplatsen. Men vad händer om meddelandena från webbplatsen inte längre är skräppost? Till exempel vill du återställa ditt lösenord. En webbplats skickar ett e-postmeddelande med en länk till ett formulär för återställning av lösenord, men du kan inte ta emot det eftersom filtret omedelbart raderar e-postmeddelandet.
Lyckligtvis finns det en elegant väg ut ur denna situation. Du kan tillfälligt konfigurera om filtret så att det inte tar bort dessa e-postmeddelanden. Eller så kan du ta bort filtret helt. Låt oss se hur detta kan göras.
Öppna först Gmail-webbgränssnittet. Klicka på knappen ”Inställningar” på sidan som öppnas:
I fönstret som öppnas klickar du på knappen ”Se alla inställningar”:
Fönstret Gmail-kontoinställningar öppnas. Den innehåller många flikar för att finjustera din e-postupplevelse. Vi är intresserade av fliken ”Filter och blockerade adresser”. Öppna den här fliken:
På fliken som öppnas ser du en lista med filter för de genererade Gmails som du skapade tidigare, liksom eventuellt andra filter:
Genom beskrivningen av filtren kan du enkelt bestämma vilken som är ansvarig för adressen du vill avblockera. Genom att klicka på knappen ”radera” kan du permanent inaktivera filtret. Om du klickar på knappen ”redigera” kan du konfigurera om filtret. Istället för att ta bort e-postmeddelanden kan du till exempel flagga dem. På så sätt kan du spara filtret och göra det lättare att slå på det i framtiden. Genom att redigera filtret kommer du att kunna ta emot nödvändiga e-postmeddelanden från webbplatsen. Så snart du vill blockera genererad Gmail tillbaka öppnar du filtret igen med ”redigera” -knappen och konfigurerar om åtgärderna.
Det är allt. Du är nu ett proffs med genererade Gmail-adresser. Du kan skapa ett stort antal adresser och mästerligt hantera flödet av e-postmeddelanden som kommer till din Gmail. Med hjälp av ytterligare adresser kommer du att kunna spåra webbplatser som överför dina data till tredje part utan ditt samtycke. Du kommer att kunna blockera skräppost utan att behöva omskola ditt anti-spamsystem eller utan att behöva trycka på Avprenumerationsknapparna flera gånger. Du kan automatisera borttagning av skräppost med Aspose.Email .NET eller manuellt via inställningarna och Gmail-gränssnittet.