integration mellem silverpop og pivotal - Danmarks Tekniske ...

Christian Schoubye Hansen
Kongens Lyngby, januar 2010
IMM-B.Eng-2010-01
INTEGRATION
MELLEM
SILVERPOP OG PIVOTAL

Technical University of Denmark
Informatics and Mathematical Modelling
DTU – Building 321, DK-2800 Kongens Lyngby, Denmark
Phone +45 45253351, Fax +45 45882673
reception@imm.dtu.dk
www.imm.dtu.dk
IMM-B.Eng-2010-01
Side 2

Abstrakt
Hos FOSS er man interesseret i at kunne lave nye former marketing kampagner, som kan generere
mere salg.
Silverpop er et amerikansk firma, som har specialiseret sig i email marketing kampagner.
Ved at bruge deres produkt, kan man lave dynamiske kampagner. Hvor man leverer lige præcist
den information, som er inden for kundens forretningsområde.
Målet med dette projekt er at lave synkronisering begge veje mellem Silverpop og FOSS’ CRM
system, Pivotal.
Endvidere skal data kunne behandles i Pivotal og kunder skal have mulighed for at kunne afmelde
sig marketings e-mails fra FOSS.
Side 3

Forord
Denne rapport er en afhandling for en Bachelor grad i Engineering. Den blev lavet ved Institut for
Informatik og Matematisk Modellering, ved Danmarks Tekniske Universitet.
Afhandlingen omhandler synkronisering mellem 2 computer systemer. Den er inddelt i 3
hovedområder, først analyse af de forskellige platforme, derefter designe en god måde at
implementere en synkronisering og til sidst selve implementationen.
Afhandlingen er lavet mellem 2/11-2009 og 22/01 2010
Christian Schoubye Hansen
Kongens Lyngby, januar 2010
Side 4

Indholdsfortegnelse
Abstrakt ................................................................................................................................................ 3
Forord ................................................................................................................................................... 4
Indledning ............................................................................................................................................ 7
FOSS ................................................................................................................................................. 7
Silverpop .......................................................................................................................................... 7
Krav specifikation til integrationsprojektet ..................................................................................... 8
Analyse ................................................................................................................................................. 9
Platformens Teknologi ..................................................................................................................... 9
Pivotal Tabel design / konstruktion ............................................................................................... 11
Tabel vindue ............................................................................................................................... 11
Pivotal Forms .................................................................................................................................. 13
Pivotal agenter ............................................................................................................................... 14
Løkker i agenter ......................................................................................................................... 14
Silverpop ........................................................................................................................................ 15
Data der skal sendes fra Pivotal til Silverpop............................................................................ 16
Data fra Silverpop til Pivotal ...................................................................................................... 16
Design ................................................................................................................................................. 17
Tabel opbygning i Silverpop. .......................................................................................................... 17
Nye tabeller i Pivotal ...................................................................................................................... 17
Synkronisering af data fra Pivotal til Silverpop .............................................................................. 18
Synkronisering fra Silverpop til Pivotal .......................................................................................... 19
Unsubscribe .................................................................................................................................... 19
Implementering.................................................................................................................................. 20
Unsubscribe agent ......................................................................................................................... 20
Data fra Pivotal til Silverpop agent ................................................................................................ 22
Data fra Silverpop til Pivotal agent ................................................................................................ 24
Data fra Pivotal til Silverpop C# kode ............................................................................................ 25
ConsoleApplication1 / SilverpopIntegration .............................................................................. 25
Data fra Silverpop til Pivotal C# kode ............................................................................................ 26
Return Silverpop Data ................................................................................................................ 26
Side 5

Test ..................................................................................................................................................... 28
Konklusion .......................................................................................................................................... 29
Opfyldte krav i forhold til løsningen .............................................................................................. 29
Tilfredshed fra marketing afdelingen ............................................................................................ 29
Benefit for forretningen ................................................................................................................. 29
Fremtidig udvikling ......................................................................................................................... 29
Bilag .................................................................................................................................................... 30
Pivotal Agenter ............................................................................................................................... 30
Return Silverpop Data C# ............................................................................................................... 32
App.config .................................................................................................................................. 32
ByteConvertor.cs ........................................................................................................................ 33
CsvParser.cs ................................................................................................................................ 35
ErrorMailGenerator.cs ............................................................................................................... 38
Log.cs .......................................................................................................................................... 39
SilverpopAPI.cs ........................................................................................................................... 41
SilverpopFTP.cs .......................................................................................................................... 50
TransactionalDatabase.cs .......................................................................................................... 52
Program.cs ................................................................................................................................. 54
ConsoleApplication1 C# ................................................................................................................. 57
App.config ...................................................................................................................................... 57
ByteConvertor.cs ........................................................................................................................ 58
CsvFileGenerator.cs ................................................................................................................... 60
SilverpopAPI.cs ........................................................................................................................... 64
SilverpopFTP.cs .......................................................................................................................... 72
Program.cs ................................................................................................................................. 74
MainList.xml ............................................................................................................................... 80
Side 6

Indledning
Konkurrencen om kunderne og salg skærpes væsentligt med den nuværende krise. Hos FOSS
sælger man et mindre antal apparater men til en meget høj pris per styk. Dermed er ethvert salg
af allerstørste vigtighed for virksomheden. Man er derfor interesseret i nye tiltag, som kan
generere mere salg.
Et af de nye tiltag hos FOSS er ”Silverpop Engage”. Der er tale om en platform, der vil gøre det
muligt at lave dynamiske marketing kampagner. Det er nødvendigt at gøre det nemt for
marketingsafdelingen at bruge Silverpop, og derfor ønsker man at integrere Silverpop med FOSS’
CRM system, som indeholder alle kundeoplysninger.
FOSS
FOSS blev grundlagt i 1956 af Nils Foss. Målet var at lave automatiske analyse apparater til
landbruget. Tidligere havde man brugt manuelle analyse metoder, hvilket var meget
tidskrævende.
Man opfandt et apparat, som var lille og meget robust. Landmanden kunne tage det med ud på
marken og hurtigt måle indholdet af fugt i korn. Det blev en stor succes.
Senere begyndte man også at lave analyse apparater til mejeri og kød industrien. Med købet
af Perstorp Analytical AB i 1997, blev konceptet udvidet til også at omfatte produktion af analyse
apparater til mel, øl, farmaceutisk og kemisk industri.
FOSS er i dag en global virksomhed med salgskontorer over det meste af verdenen. Det er stadig
en familieejet virksomhed, der i dag er ledet af Nils Foss’ søn Peter Foss.
Silverpop
Silverpop er et amerikansk firma, der har udviklet en web baseret platform, som virksomheder kan
benytte til at lave marketing kampagner.
Silverpop giver mulighed for at vælge mellem forskellige informationsformer f.eks ved udsendelse
af e-mail eller sms.
Man har også mulighed for at få en rapport over en marketing kampagne. I den kan man f.eks. se
om en e-mail er bounced, dvs. den ikke nåede frem til modtageren. Derudover kan man se om
modtageren åbnede e-mailen og om modtageren klikkede på nogle links i e-mailen.
Man kan også lave dynamiske e-mails, som indeholder generel information til alle kunder og
specifik information til alle kunder indenfor et marked segment. Når man sender
nyhedsinformationen ud, baseres den på et eller flere kriterier. Eksempel på specifik information:
kødindustrien får nyheder om kødprodukter og mejerier får nyheder om mejeriprodukter.
Side 7

Krav specifikation til integrationsprojektet
Det er et krav at kunne synkronise data fra Pivotal til Silverpop. Det drejer sig om contacts, leads
og prospects. Contacts er kunder, der har købt hos FOSS før. Leads og prospects er nye potentielle
kunder, der har udtrykt interesse for FOSS produkter.
Forskellen på et lead og et prospect er mængden af data om kunden. Hvis der kun er et navn og en
e-mail, så bliver personen oprettet som et prospect. Når man får flere data, kan man så opgradere
personen til et lead.
Det er et krav at kunne synkronisere data fra Silverpop tilbage til Pivotal. Her er det data om de
enkelte e-mails, man er interesseret i. Om en e-mail kom frem eller om den blev bounced. Om
kunden åbnede e-mailen og evt. klikkede på nogle links i den.
De forskellige skærmbilleder skal opdateres i Pivotal, så man kan se, hvordan den enkelte
marketing kampagne gik. Hvor mange der modtog e-mailen, og hvor mange der var interesseret i
indholdet.
Der skal også laves en unsubscribe funktion, så kunder kan afmelde nyheds- og reklame e-mails.
Dette er et lov krav. Det skal både kunne lade sig gøre i Pivotal og via en hjemmeside.
Det skal også være muligt at resubscribe igen, hvis en kunde ønsker det.
Unsubscribe via hjemmesiden er ikke en del af dette projekt. Det vil de udviklere, der
programmerer FOSS’ hjemmeside sørge for kommer til at virke.
Når en kunde bliver afmeldt nyheds e-mails, skal de interesseområder, som kunden i første
omgang skrev sig op til, slettes, så de ikke indgår i søgeresultater fra queries.
Det sidste krav er at designet af databasen og synkroniseringsprogrammet skal gøre yderligere
udvikling mulig. Dette er nødvendig for både for at kunne imødekomme nye ønsker fra marketing
afdelingen, og også for at kunne tilpasse synkroniseringsprogrammet til et nyt CRM system.
Side 8

Analyse
Platformens Teknologi
Hos FOSS bruger man Pivotal eRelationship CRM system.
CRM står for “Customer Relationship Management” system.
Systemet bruges til 3 hovedområder.
Marketing til at holde styr på potentielle kunder samt kunder, som har handlet før hos FOSS. Det
vil sige anvendelse af disse oplysninger i forbindelse med marketing kampagner.
Salg, for at kunne følge op på kunder, der har udtrykt interesse for at købe et produkt. Opfølgning
på alle muligheder for et salg er vigtig for virksomheden.
Service og support til de instrumenter, som kunder har købt. I den forbindelse bruges det både til
at håndterer fejl hos en kunde, og også til versionsstyring af de enkelte instrumenter. I tilfælde af
fejl kontakter kunden det lokale salgsselskab, som opretter en support incident på kundens
instrument i Pivotal. Service afdelingen i Danmark håndterer alle support incidents. Hvis det er en
generel fejl, slår man op i Pivotal, og finder alle de kunder, som har et tilsvarende instrument.
Derefter sendes en besked ud til alle salgsselskaberne, om at sende en tekniker ud og opdatere
kundernes instrumenter.
Side 9

Pivotal er bygget op med en master server i Danmark og en masse satellit servere rundt om i
verden. Det skal medvirke til at sikre at salgsselskaber over hele verden får rimelig hurtig adgang
til Pivotal, og at serverne ikke overbelastes. Data bliver synkroniseret mellem master serveren og
de enkelte satellit servere rundt om i verden. Man kan køre Pivotal enten direkte koblet op til
master server via en Citrix klient eller med et mobilt system mod en satellit server. Når man kører
med et mobilt system har man et udsnit af dataene i en lokal database på ens computer, og når
man er logget på internettet, synkroniserer ens pc data til serveren via en web service.
Når man opretter en tabel i Pivotal kan man vælge, om den skal blive synkroniseret eller ej. Der er
dog den begrænsning, at hvis et program udenfor Pivotal opdaterer data i en tabel, så bliver
denne tabel ikke længere synkroniseret videre. Det er derfor nødvendigt at lave flere tabeller,
hvor man kan opdaterer i én tabel, og derefter bruger en Pivotal agent til at opdatere dataene i en
anden tabel, som så kan synkronisere videre.
Side 10

Pivotal Tabel design / konstruktion
Alt i Pivotal er lavet, så man skal klikke sig rundt i forskellige vinduer for at lave nye tabeller, forms,
queries og agenter. Det gør, at det umiddelbart er let at lave ting i Pivotal, at komme i gang. Men
det er meget svært at lave komplicerede ting, fordi Pivotal agenterne hurtigt gør det uoverskueligt
og overblikket for nemt mistes.
Tabel vindue
Her kan man oprette nye felter og beslutte om tabellen skal synkronisere. Man angiver også her
hvilken form, der skal være tilknyttet til tabellen, og om folk skal have mulighed for at lave queries
på tabellen. Endvidere kan man lave indexes og lister, som brugerne kan anvende i deres oversigt,
så de ikke behøver at lave queries hver gang.
Side 11

Under Add Table Field, kan man angive feltnavn, type, om det er en fremmednøgle og man kan
sætte en default formular, som indsætter en default værdi i et felt, hvis brugeren ikke selv
indtaster noget.
Side 12

Pivotal Forms
De skærmbilleder brugerne ser i Pivotal, kaldes forms.
Forms opbygges af grupper. Inden i grupperne kan man have primære og sekundære felter.
Primære felter stammer fra den tabel, man laver formen over. Sekundære felter kommer fra
andre tabeller og kræver en fremmednøgle relation.
Man placerer henholdsvis felterne og grupperne ved at angive, hvordan de skal ligge i forhold til
henholdsvis andre felter / grupper rundt om.
Sekundære felter bliver altid vist som rækker, de kan ikke vises som enkelte felter.
Side 13

Pivotal agenter
Den eneste måde man kan kode i Pivotal er ved at arbejde med såkaldte ”agenter”. Agenter er
opbygget af komponenter, og flowet vises med pile.
Hver komponent kan forskellige ting og virker på forskellige niveauer. ”Form komponenten” kan
kun arbejde med felter fra én form. En ”record komponent” kan arbejde med al data fra en tabel,
og kan derudover baseres på queries.
Generelt om komponenter. Hvis en komponent gennemløbes uden fejl, fortsætter agenten videre
fra komponentens venstre ben. Hvis der er fejl, går den ud fra komponentens højre ben. Hvis et
ben ikke er forbundet videre, vil agenten stoppe.
Hvis man bruger en test komponent, vil den gå ud ad venstre ben, hvis kriteriet var sandt. Hvis
kriteriet er falsk, går den videre ud ad højre ben.
For en gennemgang af de mest brugte komponenter se bilag.
Løkker i agenter
Løkker er nødvendige, når man vil kalde den samme komponent flere gange. Det kan være nyttigt,
hvis man for eksempel vil opdatere 1000 records i en agent. Man laver en record komponent, der
udfører de ønskede opdateringer. Den kan dog kun arbejde på én record af gangen, og når den er
færdig, går agenten videre til en anden komponent. Derfor bliver man nødt til at kalde den samme
komponent flere gange, indtil der ikke er flere records, der skal opdateres. Konventionen i Pivotal
er at lave en shortcut til record komponenten, som det kan ses i figuren ovenover.
Side 14

Herefter sætter man record komponenten til at finde de records, der skal opdateres. I shortcut
komponenten laver man de ønskede opdateringer. Når record komponenten ikke finder flere
records, brydes løkken, og agenten kører videre ad record komponentens højre ben.
Silverpop
Man logger ind på Silverpop via deres hjemmeside og kan derfra oprette lister / tabeller og
relatere dem til hinanden. Der er også der, man kan lave rapporter, queries samt lave og udsende
e-mail kampagner.
En lidt speciel ting i Silverpop er, at man ikke kan forbinde relational tables med hinanden. De kan
kun forbindes til en liste, og ikke til andre tabeller. Listen kan forbindes med alle de tabeller, man
har lyst til.
Man skal være opmærksom på, at email adressen er et påkrævet felt i Silverpop, som skal være
unikt for hver record, for at man kan lave email kampagner.
Side 15

Man kan desuden også oploade til Silverpop via FTP. Der skal man oploade 2 filer. En CSV fil med
data og en XML fil med instruktioner. I XML filen kan man specificere om man vil oploade data og
man kan også samtidig oprette tabeller, og linke tabeller. Man har også mulighed for at angive at
man vil slette de records hos Silverpop, som matcher med dem, man oploader i en CSV fil.
Data der skal sendes fra Pivotal til Silverpop
Marketing afdelingen vil have at følgende felter bliver synkroniseret fra Pivotal til Silverpop.
Company ID, Company Name, Contact ID, First Name, Last Name, Job Title, Country, E-mail,
FOSS RSM, First Name, Last Name, Job Title, Company, E-mail, Phone, fra contact tabellen.
RSM står for Regional Sales Manager. Det er den salgsmanager, der er ansvarlig for det land /
område, som kunden bor i.
Desuden er man interesseret i interest areas for kunden. Det er de områder, som kunden har
ønsket at modtage informationer om. For contacts er det også interessant at vide hvilke
produkter, kunden har købt. Derfor skal products og den product group de tilhører også
synkroniseres til Silverpop.
Man er interesseret i de tilsvarende felter for leads, også i deres interest areas.
Data fra Silverpop til Pivotal
Informationen fra Silverpop skal tilføjes til tabellen Rn_appointments og vises på skærmbilledet
Marketing Activity.
Fra marketing er man interesseret i at få følgende informationer overført fra Silverpop til Pivotal.
Navnet og tidspunktet for marketing kampagnen. Om kunden åbnede e-mailen og klikkede på
nogle links. Om e-mailen blev Soft bounced eller Hard bounced. Hvis e-mailen blev åbnet eller
bounced skal datoen for den hændelse også gemmes.
En e-mail er Hard bounced, når det er en ugyldig e-mail adresse, man har sendt til. Soft bounced
kan betyde flere ting. Det kan f.eks. være at man har sendt til en overfyldt e-mail, som derfor ikke
kan modtage flere e-mails.
Side 16

Design
Tabel opbygning i Silverpop.
Datastrukturen i Silverpop bygges op på følgende måde. En hovedliste og 3 tabeller.
Listen indeholder alle oplysninger om den enkelte kunde. Det kan være både en contact eller et
lead. Til listen er tilknyttet 3 tabeller. Products indeholder alle de apparater, som den pågældende
kunde har købt. Interest area er de områder, kunden har udtrykt interesse for. Preferred Com
Methods indeholder information om de kontaktformer, kunden ønsker. Det kan være at kunden
gerne vil have nyheder på e-mail og også gerne vil have In Focus magasinet tilsendt i papir form.
En kunde kan have flere products, interest areas og preferred com methods.
Nye tabeller i Pivotal
For at kunne lave synkronisering indenfor pivotal, er der brug for 3 nye tabeller i Pivotal.
Silverpop in Indeholder alle data, der kommer fra Silverpop.
Silverpop out Indeholder data, der skal til Silverpop.
Silverpop temp Indeholder contact og lead id for alle de records, der skal synkroniseres fra
Pivotal til Silverpop.
Side 17

Synkronisering af data fra Pivotal til Silverpop
Første skridt er opsamling af data fra Pivotal. Det vil sige alle contacts og leads, der lige er blevet
oprettet i Pivotal, og derfor ikke er i Silverpop endnu. Derudover alle de contacts og leads, der er
blevet ændret siden sidste synkronisering.
Disse records skal markeres eller gemmes i en særskilt tabel. Dermed ved man hvilke records, der
skal sendes til Silverpop ved den næste synkronisering. Fra marketings side vil man gerne have at
data bliver synkroniseret en gang i døgnet. På den måde forstyrrer man færrest brugere af Pivotal.
Der går lidt tid mellem hver marketing kampagne, så er det rigeligt med een synkronisering i
døgnet.
Der skal også holdes styr på den enkelte record. Er der tale om en kunde, der har afmeldt e-mails
fra FOSS, skal kundens record slettes fra hovedlisten i Silverpop.
Fra marketing vil man gerne have muligheden for at kunne genopskrive kunder til marketing emails,
hvis kunden ønsker det. Man skal samtidig kunne se i pivotal om en contact eller lead har
ønsket at afmelde og genopskrive til marketing e-mails.
Man kunne vælge at lade Silverpop styre unsubscribes. Hvis man tog den løsning, ville der være et
link i hver e-mail, hvor kunden kunne ind på en Silverpop hjemmeside og afmelde sig der. Fra
Silverpops side har man valgt, at hvis en kunde unsubscriber via deres system, kommer kundens email
adresse ind på en afmeldt liste, og derefter kan man aldrig sende e-mails til ham igen. Derfor
ønsker marketing, at afmeldinger bliver håndteret i Pivotal.
Dette betyder, at alle de kunder, som er i Silverpop, ønsker at modtage e-mails. Hvis en kunde
afmelder sig, skal kundens oplysninger slettes fra Silverpop.
Når der er styr på alle de records, der skal oploades, skal dataene læses fra Pivotal og sendes til
Silverpop. Det er umuligt via agenter i Pivotal. Der skal et program udefra for at gøre det. Valget
faldt på C#. Det er et naturligt valg, fordi det er det sprog, man bruger i FOSS i andre
sammenhæng. Det bruges til hjemmesiden og er blevet brugt til andre integrationsprojekter.
Til sidst skal dataen fra Pivotal lægges i en CSV fil og sammen med en XML fil oploades til
Silverpop.
Side 18

Synkronisering fra Silverpop til Pivotal
For at få data fra Silverpop, skal man sende en XML fil med en export request. Silverpop genererer
derefter en CSV fil. Den indeholder alle de records, som er blevet bounced, åbnet eller andet,
siden sidste gang man lavede en export fra Silverpop.
Filen bliver pakket med zip, og lagt på Silverpops server under ftp mappen.
Den skal downloades og pakkes ud.
Dataene skal derefter lægges ind i Silverpop in tabellen i Pivotal. Alt dette skal ske i C#
programmet.
I Pivotal skal der laves en agent, der læser dataene fra Silverpop in tabellen og gemmer dataene i
tabellen Rn_appointments. Dermed kan data fra Rn_appointments blive synkroniseret igennem
Pivotal til resten af verden.
Data fra Rn_appointments vises på skærmbilledet Marketing Activity.
Unsubscribe
Der skal laves en agent, der kan afmelde contacts og leads. Den gælder i de situationer, hvor en
kunde ikke ønsker at modtage nogen information fra FOSS overhovedet.
Den skal køres, når en superbruger sætter hak i en tjekboks. Den skal vises på skærmbillederne for
contact, lead og prospects.
Når den bliver kørt, skal den i kommentarerne skrive navnet på den superbruger, der har afmeldt
kunden samt tidspunkt for afmeldelsen.
Den skal fjerne alle kundens Preferred com methods og sørge for, at kunden bliver fjernet fra
Silverpop.
Det skal også være muligt at genopskrive kunden igen via denne agent.
Side 19

Implementering
Unsubscribe agent
Agenten bliver kørt enten fra contact, lead eller prospects formen.
Man er ikke interesseret i, at nogen kommer til at afmelde en kunde ved en fejl. Derfor har man
valgt, at det kun er superbrugere, der har lov til at afmelde kunder.
Det første agenten undersøger, er om brugeren har de nødvendige rettigheder, dvs. er
superbruger.
Hvis det er tilfældet, går agenten videre og undersøger, om kunden er blevet unsubscribed før.
Det vil sige, om unsubscribed boolean er sat til sandt (check unsubscribe flag). Hvis den er sandt,
bliver brugeren bedt om at bekræfte, at kunden skal kunne modtage e-mails / magasiner igen.
Flaget bliver fjernet fra unsubscribe, og brugerens navn og tidspunkt gemmes under noter på
kundens record (unset unsubscribe). Derefter opdateres formen, så det igen er muligt at tilføje,
om kunden ønsker at modtage skrivelser.
Side 20

Skal kunden afmeldes (no ved check unsubscribe flag), kommer der en meddelelse til brugeren.
Når den er blevet bekræftet, sættes unsubscribe flaget til sandt. Derefter løbes alle kundens
preferred com methods igennem, arkiveres, og listen slettes.
Når der arkiveres en preferred com methods record betyder det at der oprettes en archive
preferred com methods record. Den indeholder kunde record Id, preferred com method type,
tidspunkt og om det er en tilføjelse eller sletning. Det vil sige, at det bliver arkiveret, når en kunde
ønsker at modtage nyheds- og reklame e-mails og når han frabeder sig det. Dermed er der en
komplet historik. Hvis en kunde klager over at modtage e-mails, kan man slå op i tabellen og se om
han har tilmeldt sig og evt. afmeldt sig igen.
Hvis der har været nogle opdateringer af kundens stamdata, vil der være blevet oprettet nogle
records i Silverpop temp. Disse bliver fjernet fra tabellen (remove other silverpop temp records).
Der bliver lavet en ny record i Silverpop temp med kundens record id, e-mail adresse og deletion
sat til sand. Dermed bliver kundens oplysninger slettet fra Silverpop efter næste synkronisering, og
kunden vil efterfølgende ikke modtage flere e-mails.
Til sidst bliver formen opdateret. Det er derefter ikke muligt at sætte kunden til at modtage
skrivelser.
Side 21

Data fra Pivotal til Silverpop agent
Agenten kører en gang i døgnet ved midnat.
Agenten læser fra Silverpop temp tabellen efter en query, som tester om agent_handled er falsk.
Derefter bliver der testet, om det er en deletion. Hvis det er tilfældet, bliver der oprettet en record
i Silverpop out tabellen, med contact / lead Id, E-mail, company Id og deletion sat til sandt. Hvis
det ikke er en deletion, bliver der testet, om det er et lead (Is this a lead). Det efterfølgende er ens
for contacts og leads. Den eneste forskel er, at det drejer sig om forskellige tabeller.
Først bruges Id’et fra Silverpop temp til at hente den originale record frem. Der undersøges om
den record har en e-mail adresse. Det er kun interessant at synkroniserer kunder med e-mail
adresser til Silverpop.
Derefter oprettes en record i Silverpop out tabellen. I den record gemmes kunde og RSM
oplysninger.
Side 22

Bagefter bliver Set Business area kørt. Business area er det samme som interest area. Den finder
alle kundens interest areas, og gemmer dem i Silverpop out recorden. Til sidst slettes den
nuværende record i Silverpop temp, og agenten læser den næste record fra Silverpop temp.
Hvis der på noget tidspunkt opstår en fejl, vil der blive sendt en mail til en Pivotal programmør.
Silverpop temp recorden vil blive sat til agent_handled sandt, og agenten vil springe den record
over og tage den næste. Når der ikke er flere records i Silverpop temp, går agenten i sleep mode.
Den vågner op igen ved midnat, og ser efter flere records i Silverpop temp.
Side 23

Data fra Silverpop til Pivotal agent
Agenten kører altid, men er sat til at sove i 2 minutter, når der ikke er flere records i Silverpop in.
Agenten læser fra Silverpop in tabellen efter en query. Den query frasorterer records, hvor
agent_handled er sat til sandt.
I test komponenten tester agenten, om det er en contact. Det er enten en contact eller et lead.
Derefter opdateres den pågældende record, hvis e-mailen til kunden bounced.
Bagefter laves en ny record i Marketing Activity. Den bliver udfyldt med navnet på marketing email
kampagnen og tidspunkt.
Hvis der er blevet klikket på nogle links, eller e-mailen er blevet soft eller hard bounced, bliver
dette tilføjet under noten på recorden. Derudover bliver datoen for disse events også gemt på
recorden.
Til sidst slettes Silverpop in recorden, og agenten starter forfra med den næste record fra tabellen.
Side 24

Hvis der opstår fejl undervejs, bliver fejl recorden gemt med agent_handled sat til sandt, og der
bliver sendt en mail til en Pivotal programmør. Agenten kan derefter køre videre med en anden
record.
Data fra Pivotal til Silverpop C# kode
ConsoleApplication1 / SilverpopIntegration
Denne kode læser data fra Pivotal i tabellen Siverpop out, behandler det og sender det til
Silverpop.
Der er App.config, som indeholder praktiske oplysninger, så som server adresse, user name,
passwords og e-mail adresser. Dermed er det nemmere at finde, når man skal opdatere nogle af
disse oplysninger.
Selve C# programmet består af en række filer. De er delt op så hver fil, er en separat funktion.
Program.cs Hovedprogrammet, styrer processen og kalder
funktioner fra de andre filer.
Log.cs Bruges igennem det meste af programmet til at logge
events til en log fil.
ErrorMailGenerator.cs Sender en e-mail ud i tilfælde af fejl.
CsvFileGenerator.cs Funktioner til at generere csv filer.
ByteConvertor.cs Bruges til at generere og håndtere record ids til Pivotal.
Bemærk! Jeg har ikke lavet denne fil.
SilverpopAPI.cs Bruges til at logge på og ud af Silverpop.
SilverpopFTP.cs Bruges til at sende og modtage data fra /til Silverpop
TransactionalDatabase.cs Bruges til alle database kald.
Program forløb:
Først hentes de records ud fra Pivotal, som skal slettes i Silverpop. Deres Id bliver konverteret ved
hjælp af ByteConvertor.cs. Det er på grund af at Ids i Pivotal, er i et meget specielt format. Der
Side 25

findes ingen dokumentation om det og de kunne ikke forklare det. Derfor valgte jeg at bruge den
fil, de plejer at bruge, ByteConvertor.cs. Jeg har derfor ikke selv lavet denne fil.
Efter konverteringen bliver XML filen oploadet til Silverpop, som sletter de pågældende records.
Derefter indlæses de records fra Pivotal, som skal opdateres i Silverpop. Der bliver genereret 4
XML filer: MainList.xml, pref_comm.xml, products.xml og ba.xml.
XML filerne indeholder kommandoer til Silverpop. Hvor der bliver specificeret at de skal
add_and_update, dvs. opdatere record, hvis den findes i forvejen ellers lav en ny. Derudover
indeholder de navnet og id på den tabel eller liste, der skal opdateres i Silverpop. Efter det bliver
kolonnerne listet og deres placering i CSV filen angivet.
Til sidst bliver XML og CSV filerne oploadet til Silverpop. Hver opload bliver kørt i hver sin tråd.
Dermed skal de ikke vente på at den foregående opload er blevet færdigbehandlet i Silverpop.
Data fra Silverpop til Pivotal C# kode
Return Silverpop Data
Denne kode henter data fra Silverpop, behandler det og sender det til Pivotal til tabellen Silverpop
in.
Der er ligesom i den foregående kode en App.config fil, som indeholder praktiske oplysninger.
C# programmet er også bygget op på samme måde som før.
Program.cs Hovedprogrammet, styrer processen og kalder
funktioner fra de andre filer.
Log.cs Bruges igennem det meste af programmet til at logge
events til en log fil.
ErrorMailGenerator.cs Sender en e-mail ud i tilfælde af fejl.
CsvParser.cs Funktioner til at læse en csv file og indlæse i et
DataTable.
ByteConvertor.cs Bruges til at generere og håndtere record ids til Pivotal.
Bemærk! Jeg har ikke lavet denne fil.
SilverpopAPI.cs Bruges til at logge på og ud af Silverpop.
SilverpopFTP.cs Bruges til at sende og modtage data fra /til Silverpop
Side 26

TransactionalDatabase.cs Bruges til alle database kald.
Program forløb:
Først sendes en export request til Silverpop. Silverpop genererer en zip fil, der indeholder en CSV
fil, med data. Filen downloades via FTP.
CSV filen pakkes ud og zip filen slettes, for at begrænse mængden af filer på serveren.
Herefter er det meningen at CSV filen skal indlæses i programmet og bagefter skrives til Silverpop
in tabellen i Pivotal.
Dette virker på nuværende tidspunkt ikke. Der er en fejl, når CSV filen bliver indlæst til et
DataTable. Den returnerer et tomt DataTable og der er derfor intet at indlæse til Pivotal.
Side 27

Test
Jeg har lavet manuel testning af de forskellige programdele. Jeg har testet ved at løbende at lave
udskrifter til skærmen både i Pivotal og i C# koden. Det er ikke muligt at teste på andre måder i
Pivotal. Derudover har jeg kørt programmet og kontrolleret at data blev flyttet rigtigt fra tabel til
tabel og fra Pivotal til Silverpop.
Alle agenter er testet og virker. De stedet hvor jeg ikke har haft data fra C# koden, har jeg manuelt
lagt data ind i tabellerne.
Jeg har haft brugere fra marketing afdelingen til at teste at dataene blev synkroniseret fra Pivotal
til Silverpop.
De kunne bekræfte at dataene kom frem til Silverpop, men derudover var de meget usikre på
hvordan man fandt rundt i Pivotal og hvordan man brugte Silverpop.
Som følge af testen ville de gerne have at Interest Areas også kom hen i MainList i Silverpop.
Dermed kunne de bedre overskue at teste i Silverpop.
Jeg har derfor ændret koden så alle interest areas, også ligger i MainList som booleans.
Jeg har undervejs mens jeg lavede programmerede kun arbejdet på test servere. I og med at
marketing sagde god for synkroniseringsdelen fra Pivotal til Silverpop, er denne del blevet sat i
produktion.
Side 28

Konklusion
Opfyldte krav i forhold til løsningen
Synkronisering fra Pivotal til Silverpop. Denne del er lavet og testet, at det virker korrekt. Det er i
produktion i dag.
Synkronisering fra Silverpop til Pivotal. Denne del virker ikke. Fejlen begrænser sig dog til
Csvparseren. Alle de andre komponenter i C# koden er blevet testet. Agenten, der skal håndterer
dataene i Pivotal, er også blevet testet og virker også.
Skærmbilleder og tabel opdateringer. Disse er implementeret.
Unsubscribe og resubscribe funktion. Dette er også implementeret. Det er også testet at agenten
får unsubscribet kunden, fjernet interest areas og at kunden bliver fjernet fra Silverpop efter
næste synkronisering.
Fleksibelt designet. Dette punkt vil jeg mene er opnået. Jeg har brugt få agenter, og disse er
forsøgt at være overskuelige. C# koden er delt op i en række filer, med hver deres
funktionsområde.
Tilfredshed fra marketing afdelingen
Marketing afdelingen er tilfreds med at data bliver synkroniseret til Silverpop. Dermed har de data
klar og kan lave nogle testkampagner. At synkroniseringen ikke virker tilbage til Pivotal, er ikke et
stort problem på nuværende tidspunkt. De har travlt med at rydde op i dataene i Pivotal. Der er en
masse manuelt arbejde i at finde ud af, hvem man skal sende e-mails til, hvis flere kunder har den
samme e-mail adresse.
Benefit for forretningen
Marketing afdelingen slipper for at manuelt skulle lave filer med 5-20000 records der skal manuelt
importeres. Dermed spares der meget tid.
Man har mulighed for at lave dynamiske e-mail kampagner. De rammer kunderne bedre med
mere specifikt information til dem. Dermed burde det genererer mere salg.
Fremtidig udvikling
Synkroniseringen fra Silverpop til Pivotal skal gøres færdig.
Der kommer givet mere, der skal laves om, når marketing begynder at bruge Silverpop og Pivotal.
Jeg forventer at de både vil have mere data til og fra Silverpop. I Pivotal vil have mere data på
contact og lead formene og en række queries. Dermed kan de begynde at måle effektiviteten af
deres e-mail kampagner.
Side 29

Bilag
Pivotal Agenter
Pivotal Agent Komponenter
Navn Ikon Beskrivelse
Test
Wait
Agent
Import
List
Tester et udtryk og returnerer enten sandt eller false.
Bruges til at sætte en agent til at vente i et stykke tid.
Bruges til at indlejrer en agent i en anden agent.
Komponenterne i den indlejrede agent kan bruge variablerne i
hovedagenten. En indlejret agent bruges ofte til at skjule en del
komponenter fra hovedagenten, og dermed skabe overblik.
Bruges til at importerer data ind i Pivotal. Dataene skal ligge i en
CSV fil.
Lister bruges til at vise data i Pivotal, når queries returnerer
mere end 1 record. Komponenten kan oprette, slette og
manipulere lister.
Side 30

Form
Record
Send
Variable
Move
Call
Kan læse og skrive til felter på en Pivotal Form. Kan også
manipulere de enkelte felter, f.eks. lave nogle af dem read only.
Kan læse og skrive til en record i databasen. Kan baseres på en
query, så man kun får en delmængde af dataene. Derudover
den også manipulere felter på den enkelte record.
Sender en e-mail ud. Man kan sætte modtager, cc, cb, titel og
besked i komponenten.
Bruges som en almindelig variable, til at gemme en værdi
midlertidig.
Bruges til at flytte data, f.eks. til og fra en variable.
Man kan køre andre agent med denne komponent. Agenterne
kan ikke dele variable, men man kan overfører argumenter når
man kalder call.
Side 31

Prompt
Note
Return Silverpop Data C#
App.config
Bruges til at skrive tekst og evt. variabler ud på skærmen til
brugeren. Bruges også når brugeren skal tage stilling til noget.
Kan skrive en besked ud på skærmen til brugeren.
Side 32

ByteConvertor.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace FOSS.SilverpopIntegration
{
public static class ByteConvertor
{
///
/// Converts an decimal id into an bytearray id
///
/// The decimal representation of the id
/// The Bytearray representation of the id.
public static byte[] ConvertToFossBytes(string id)
{
byte[] converted = new byte[8];
string binstring = "";
}
if (id.Contains("-"))
{
string[] num = id.Split('-');
binstring = DecimalToBase(Convert.ToInt32(num[0]), 2).PadLeft(24, '0');
binstring += DecimalToBase(Convert.ToInt32(num[1]), 2).PadLeft(40, '0');
}
else
{
binstring = DecimalToBase(Convert.ToInt32(id), 2).PadLeft(64, '0');
}
for (int i = 0; i < converted.Length; i++)
{
converted[i] = (byte)BinToDecimal(binstring.Substring(i * 8, 8));
}
return converted;
///
/// Converts a bytearray representation of an id into a decimal representation of the id
///
/// bytearray representation of the id
/// the decimal representation of the id
public static string ConvertFossBytes(byte[] workid)
{
string[] BinStringArr = new string[workid.Length];
for (int i = 0; i < workid.Length; i++)
{
BinStringArr[i] = DecimalToBase(workid[i], 2).PadLeft(8, '0');
}
string Head = "";
string Tail = "";
Head = BinStringArr[0];
Head += BinStringArr[1];
Head += BinStringArr[2];
Tail = BinStringArr[3];
Tail += BinStringArr[4];
Tail += BinStringArr[5];
Tail += BinStringArr[6];
Tail += BinStringArr[7];
string HeadOut = BinToDecimal(Head).ToString();
string TailOut = BinToDecimal(Tail).ToString();
Side 33

}
}
}
if (HeadOut == "0")
return TailOut;
else
return HeadOut + "-" + TailOut;
///
/// Converts a decimal representation of a number into the "base" representation of the number
///
/// The decimal number
/// The base that the the decimal should be converted into
/// The converted number
public static string DecimalToBase(int iDec, int numbase)
{
string strBin = "";
int[] result = new int[32];
int MaxBit = 32;
for (; iDec > 0; iDec /= numbase)
{
int rem = iDec % numbase;
result[--MaxBit] = rem;
}
for (int i = 0; i < result.Length; i++)
{
strBin += result.GetValue(i);
}
strBin = strBin.TrimStart(new char[] { '0' });
return strBin;
}
///
/// Converts from binary to decimal
///
/// binary representation of the number
/// the decimal representation of the number
public static int BinToDecimal(string sBase)
{
int dec = 0;
int bit = 0;
for (int i = sBase.Length - 1; i >= 0; i--)
{
if ("1" == sBase[i].ToString())
{
dec += (int)Math.Pow(2, bit);
}
bit++;
}
return dec;
}
Side 34

CsvParser.cs
using System;
using System.Collections;
using System.Text;
using System.Data;
using System.IO;
namespace FOSS.SilverpopIntegration
{
public static class CsvParser
{
public static DataTable Parse(string data, bool headers)
{
return Parse(new StringReader(data), headers);
}
public static DataTable Parse(string data)
{
return Parse(new StringReader(data));
}
public static DataTable Parse(TextReader stream)
{
return Parse(stream, false);
}
///
/// Parses a CSV file and returns the data in a DataTable.
///
/// The Stream containing the CSV contents.
/// True if the file contains column headers.
/// Returns the CSV data in the form of a DataTable.
public static DataTable Parse(TextReader stream, bool headers)
{
DataTable table = new DataTable();
CsvStream csv = new CsvStream(stream);
string[] row = csv.GetNextRow();
if (row == null)
return null;
if (headers)
{
foreach (string header in row)
{
if (header != null && header.Length > 0 && !table.Columns.Contains(header))
table.Columns.Add(header, typeof(string));
else
table.Columns.Add(GetNextColumnHeader(table), typeof(string));
}
row = csv.GetNextRow();
}
while (row != null)
{
while (row.Length > table.Columns.Count)
table.Columns.Add(GetNextColumnHeader(table), typeof(string));
table.Rows.Add(row);
row = csv.GetNextRow();
}
return table;
}
private static string GetNextColumnHeader(DataTable table)
{
int c = 1;
while (true)
{
string h = "Column" + c++;
if (!table.Columns.Contains(h))
return h;
Side 35

}
}
private class CsvStream
{
private TextReader stream;
public CsvStream(TextReader s)
{
stream = s;
}
public string[] GetNextRow()
{
ArrayList row = new ArrayList();
while (true)
{
string item = GetNextItem();
if (item == null)
return row.Count == 0 ? null : (string[])row.ToArray(typeof(string));
row.Add(item);
}
}
private bool EOS = false;
private bool EOL = false;
private string GetNextItem()
{
if (EOL)
{
// previous item was last in line, start new line
EOL = false;
return null;
}
bool quoted = false;
bool predata = true;
bool postdata = false;
StringBuilder item = new StringBuilder();
while (true)
{
char c = GetNextChar(true);
if (EOS)
return item.Length > 0 ? item.ToString() : null;
if ((postdata || !quoted) && c == ',')
// end of item, return
return item.ToString();
if ((predata || postdata || !quoted) && (c == '\x0A' || c == '\x0D'))
{
EOL = true;
if (c == '\x0D' && GetNextChar(false) == '\x0A')
GetNextChar(true);
return item.ToString();
}
if (predata && c == ' ')
continue;
if (predata && c == '"')
{
quoted = true;
predata = false;
continue;
}
Side 36

}
}
}
}
if (predata)
{
predata = false;
item.Append(c);
continue;
}
if (c == '"' && quoted)
{
if (GetNextChar(false) == '"')
item.Append(GetNextChar(true));
else
postdata = true;
continue;
}
}
item.Append(c);
private char[] buffer = new char[4096];
private int pos = 0;
private int length = 0;
private char GetNextChar(bool eat)
{
if (pos >= length)
{
length = stream.ReadBlock(buffer, 0, buffer.Length);
if (length == 0)
{
EOS = true;
return '\0';
}
pos = 0;
}
if (eat)
return buffer[pos++];
else
return buffer[pos];
}
Side 37

ErrorMailGenerator.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Mail;
namespace FOSS.SilverpopIntegration
{
public static class ErrorMailGenerator
{
private static string recipient = System.Configuration.ConfigurationManager.AppSettings["ErrorMailRecipient"].ToString();
}
}
public static string Recipient
{
get
{
return (recipient);
}
}
public static void SendErrorMail(string body)
{
try
{
MagicalLogFile.MakeLogEntry("Sending Error Mail to " + recipient);
}
//create the mail client
SmtpClient sMail = new SmtpClient("mail.foss.dk");
sMail.DeliveryMethod = SmtpDeliveryMethod.Network;
//send the specified message
sMail.Send("silverpop@foss.dk", recipient, "Error Generated by Silverpop Integration!", body);
}
catch(Exception ex)
{
//log the error
MagicalLogFile.MakeLogEntry("Sending the Email FAILED - that's a bad thing, a very very bad thing");
MagicalLogFile.MakeLogEntry(ex.Message);
}
Side 38

Log.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Threading;
namespace FOSS
{
public class LogLock
{
private int locked;
}
public Boolean status
{
get
{
if (locked == 1) return true;
else return false;
}
}
public void LockLog()
{
while (Interlocked.CompareExchange(ref locked, 1, 0)==1)
{
Thread.Sleep(0);
}
}
public void UnlockLog()
{
Interlocked.Exchange(ref locked, 0);
}
public static class MagicalLogFile
{
private static string default_ = System.Configuration.ConfigurationManager.AppSettings["LoggingDefault"].ToString();
private static int MaxFileSize = Convert.ToInt32(System.Configuration.ConfigurationManager.AppSettings["MaxFileSize"].ToString());
private static LogLock locked = new LogLock();
public static void MakeLogEntry(string msg)
{
MakeLogEntry(msg, default_);
}
public static void MakeLogEntry(string msg, string type)
{
try
{
locked.LockLog();
if (type == "file")
{
LogMessageToFile(msg);
CheckFileSize();
}
else
{
}
}
finally
{
locked.UnlockLog();
}
}
private static string GetTempPath()
Side 39

}
}
{
}
string path = System.Environment.CurrentDirectory;//System.Environment.GetEnvironmentVariable("TEMP");
if (!path.EndsWith("\\")) path += "\\";
return path;
private static void LogMessageToFile(string msg)
{
System.IO.StreamWriter sw = System.IO.File.AppendText(
GetTempPath() + "Log.txt");
try
{
string logLine = System.String.Format(
"{0:G}: {1}.", System.DateTime.Now, msg);
sw.WriteLine(logLine);
}
finally
{
sw.Close();
}
}
private static void CheckFileSize()
{
FileInfo fi = new FileInfo(GetTempPath() + "Log.txt");
}
if (fi.Length > MaxFileSize)
{
File.Move(GetTempPath() + "Log.txt", GetTempPath() + "Log - " + DateTime.Now.ToFileTimeUtc() + ".txt");
File.Delete(GetTempPath() + "Log.txt");
}
Side 40

SilverpopAPI.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Configuration;
using System.Web;
using System.Net;
using System.IO;
using System.Threading;
namespace FOSS.SilverpopIntegration
{
public sealed class SilverpopAPI
{
private string sessionid;
private string sessionencoding;
private XmlDocument request;
private XmlDocument response;
private string jobstatus;
private string url;
private string username;
private string password;
private string jobid;
private static string MainListId = System.Configuration.ConfigurationManager.AppSettings["MainListId"].ToString();
public SilverpopAPI()
{
url = System.Configuration.ConfigurationManager.AppSettings["ApiUrl"].ToString();
username = System.Configuration.ConfigurationManager.AppSettings["Username"].ToString();
password = System.Configuration.ConfigurationManager.AppSettings["Password"].ToString();
}
request = new XmlDocument();
response = new XmlDocument();
public bool ApiLogin()
{
if (sessionid == null)
{
//create xml document
request = BuildSilverpopWrapper();
XmlElement Login = request.CreateElement("Login");
request.GetElementsByTagName("Body")[0].AppendChild(Login);
//add username and password from app.config
XmlElement usernameXML = request.CreateElement("USERNAME");
usernameXML.InnerText = username;
Login.AppendChild(usernameXML);
XmlElement passwordXML = request.CreateElement("PASSWORD");
passwordXML.InnerText = password;
Login.AppendChild(passwordXML);
//logging in
MagicalLogFile.MakeLogEntry("Logging Into Silverpop API...");
SubmitRequest();
if (response == null) return (false);
//parse the response to check if logged in, and get the sessionid
if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "true")
{
sessionid = response.GetElementsByTagName("SESSIONID")[0].InnerText;
sessionencoding = response.GetElementsByTagName("SESSION_ENCODING")[0].InnerText;
Side 41

}
MagicalLogFile.MakeLogEntry("Successfully logged in with sessionid: " + sessionid);
return (true);
}
else
{
//log an error
MagicalLogFile.MakeLogEntry("Failed to login to API :: " + response.GetElementsByTagName("FaultString")[0].InnerText);
}
return (false);
}
else
{
MagicalLogFile.MakeLogEntry("Already logged into Silverpop API");
return (true);
}
public void ApiLogout()
{
if (sessionid == null)
{
//not logged in it seems
MagicalLogFile.MakeLogEntry("Already logged out of API");
//ensure variables are reset
sessionencoding = null;
}
else
{
//create logout request
request = BuildSilverpopWrapper();
}
}
XmlElement logout = request.CreateElement("Logout");
request.GetElementsByTagName("Body")[0].AppendChild(logout);
//logging out
MagicalLogFile.MakeLogEntry("Logging out of API");
//submit request and get response
SubmitRequest();
if (response == null)
{
MagicalLogFile.MakeLogEntry("Null response when attempting to log out");
}
sessionencoding = null;
sessionid = null;
private XmlDocument BuildSilverpopWrapper()
{
XmlDocument xml = new XmlDocument();
XmlDeclaration xmlDec = xml.CreateXmlDeclaration("1.0", "utf-8", null);
XmlElement envelope = xml.CreateElement("Envelope");
xml.InsertBefore(xmlDec, xml.DocumentElement);
xml.AppendChild(envelope);
XmlElement body = xml.CreateElement("Body");
envelope.AppendChild(body);
return (xml);
}
Side 42

public void ListImport(string list)
{
if (sessionid == null)
{
MagicalLogFile.MakeLogEntry("Attempted to make an API Request without being logged in!");
}
else
{
//build our request
request = BuildSilverpopWrapper();
XmlElement ImportList_ = request.CreateElement("ImportList");
request.GetElementsByTagName("Body")[0].AppendChild(ImportList_);
XmlElement MAP_FILE = request.CreateElement("MAP_FILE");
MAP_FILE.InnerText = list + ".xml";
ImportList_.AppendChild(MAP_FILE);
XmlElement SOURCE_FILE = request.CreateElement("SOURCE_FILE");
SOURCE_FILE.InnerText = list + ".csv";
ImportList_.AppendChild(SOURCE_FILE);
//log the request
MagicalLogFile.MakeLogEntry("Sending ListImport Request to Silverpop API for list: " + list);
//make the request and get response
SubmitRequest();
//if the request was not successful record an error
if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "false")
{
MagicalLogFile.MakeLogEntry("ERROR! ListImport request returned the following fault: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//log success
MagicalLogFile.MakeLogEntry(response.FirstChild.InnerText.ToString());
jobid = response.GetElementsByTagName("JOB_ID")[0].InnerText;
}
}
}
public void TableImport(string list)
{
if (sessionid == null)
{
MagicalLogFile.MakeLogEntry("Attempted to make an API Request without being logged in!");
}
else
{
//build our request
request = BuildSilverpopWrapper();
XmlElement ImportTable_ = request.CreateElement("ImportTable");
request.GetElementsByTagName("Body")[0].AppendChild(ImportTable_);
XmlElement MAP_FILE = request.CreateElement("MAP_FILE");
MAP_FILE.InnerText = list + ".xml";
ImportTable_.AppendChild(MAP_FILE);
XmlElement SOURCE_FILE = request.CreateElement("SOURCE_FILE");
SOURCE_FILE.InnerText = list + ".csv";
ImportTable_.AppendChild(SOURCE_FILE);
//log the request
MagicalLogFile.MakeLogEntry("Sending TableImport Request to Silverpop API for list: " + list);
Side 43

make the request and get response
SubmitRequest();
//if the request was not successful record an error
if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "false")
{
MagicalLogFile.MakeLogEntry("ERROR! TableImport request returned the following fault: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//log success
MagicalLogFile.MakeLogEntry(response.FirstChild.InnerText.ToString());
jobid = response.GetElementsByTagName("JOB_ID")[0].InnerText;
}
}
}
public void TrackingMetricExport()
{
//build our request
request = BuildSilverpopWrapper();
XmlElement TME = request.CreateElement("TrackingMetricExport");
request.GetElementsByTagName("Body")[0].AppendChild(TME);
XmlElement LIST_ID = request.CreateElement("LIST_ID");
LIST_ID.InnerText = MainListId;
TME.AppendChild(LIST_ID);
XmlElement Move = request.CreateElement("MOVE_TO_FTP");
TME.AppendChild(Move);
XmlElement AAM = request.CreateElement("ALL_AGGREGATE_METRICS");
TME.AppendChild(AAM);
MagicalLogFile.MakeLogEntry("Sending Tracking Metric Export Request");
//submit the request, and get the response
SubmitRequest();
//if the request was not successful record an error
if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "false")
{
MagicalLogFile.MakeLogEntry("ERROR! TrackingMetricExport request returned the following fault: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//log success
MagicalLogFile.MakeLogEntry(response.FirstChild.InnerText.ToString());
}
}
public string RawRecipientDataExport()
{
//build our request
request = BuildSilverpopWrapper();
XmlElement RRD = request.CreateElement("RawRecipientDataExport");
request.GetElementsByTagName("Body")[0].AppendChild(RRD);
XmlElement LIST_ID = request.CreateElement("LIST_ID");
LIST_ID.InnerText = MainListId;
RRD.AppendChild(LIST_ID);
XmlElement Move = request.CreateElement("MOVE_TO_FTP");
Side 44

RRD.AppendChild(Move);
XmlElement AET = request.CreateElement("ALL_EVENT_TYPES");
RRD.AppendChild(AET);
XmlElement Columns = request.CreateElement("COLUMNS");
RRD.AppendChild(Columns);
XmlElement Column1 = request.CreateElement("COLUMN");
Columns.AppendChild(Column1);
XmlElement ConId = request.CreateElement("NAME");
ConId.InnerText = "Contact ID";
Column1.AppendChild(ConId);
MagicalLogFile.MakeLogEntry("Sending Raw Recipient Data Export Request");
//submit the request, and get the response
SubmitRequest();
//if the request was not successful record an error
if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "false")
{
MagicalLogFile.MakeLogEntry("ERROR! RawRecipientDataExport request returned the following fault: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
return (null);
}
else
{
//log success
MagicalLogFile.MakeLogEntry(response.FirstChild.InnerText.ToString());
}
}
string filename = response.GetElementsByTagName("FILE_PATH")[0].InnerText;
//get job id, and wait for it to complete
WaitOnJobStatus(response.GetElementsByTagName("JOB_ID")[0].InnerText);
return (filename);
private void SubmitRequest()
{
//build a webrequest
WebRequest wrequest = WebRequest.Create(url + sessionencoding) as HttpWebRequest;
//set request properties
wrequest.ContentType = "text/xml;charset=UTF-8";
wrequest.Method = "POST";
StringWriter sw = new StringWriter();
XmlTextWriter xw = new XmlTextWriter(sw);
//save the xml request to a text writer
request.WriteTo(xw);
System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
//convert to a byte array (the httputility thing requires a reference to system.web.dll)
byte[] byteData = encoding.GetBytes(HttpUtility.UrlPathEncode(sw.ToString()));
wrequest.ContentLength = byteData.Length;
//add data to the request
using (Stream requestStream = wrequest.GetRequestStream())
{
requestStream.Write(byteData, 0, byteData.Length);
}
//finish the request
wrequest.GetRequestStream().Close();
Side 45

}
//get the response
HttpWebResponse wresponse = (HttpWebResponse)wrequest.GetResponse();
//load the response into the response xmlDoc
response = new XmlDocument();
try
{
response.Load(wresponse.GetResponseStream());
}
catch (Exception)
{
//log an error
MagicalLogFile.MakeLogEntry("ERROR while making a request to the Silverpop API - Response could not be loaded!");
}
private void GetJobStatus()
{
if (sessionid == null)
{
MagicalLogFile.MakeLogEntry("Can't get a job status");
}
else
{
//build our request
request = BuildSilverpopWrapper();
XmlElement GetStatus = request.CreateElement("GetJobStatus");
request.GetElementsByTagName("Body")[0].AppendChild(GetStatus);
XmlElement JOB_ID = request.CreateElement("JOB_ID");
JOB_ID.InnerText = jobid;
GetStatus.AppendChild(JOB_ID);
//submit our request and get the response
SubmitRequest();
//check for a null response
if (response == null)
{
//log an error
MagicalLogFile.MakeLogEntry("Error getting Job Status for Job Id: " + jobid);
}
else if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "FALSE") //check that we can get a status for that job
{
//log an error
MagicalLogFile.MakeLogEntry("Could not get job status for job id: " + jobid + " Fault from Silverpop is: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//set the job status
jobstatus = response.GetElementsByTagName("JOB_STATUS")[0].InnerText;
//make a log of the status
MagicalLogFile.MakeLogEntry("Job status for jobid " + jobid + " is " + jobstatus);
}
}
}
public string TGetJobStatus(string id)
{
if (sessionid == null)
{
MagicalLogFile.MakeLogEntry("Can't get a job status");
return ("ERROR");
}
Side 46

else
{
request = null;
//build our request
request = BuildSilverpopWrapper();
XmlElement GetStatus = request.CreateElement("GetJobStatus");
XmlElement JOB_ID = request.CreateElement("JOB_ID");
JOB_ID.InnerText = id;// (string)Thread.GetData(loc);
GetStatus.AppendChild(request.ImportNode(JOB_ID, true));
request.GetElementsByTagName("Body")[0].AppendChild(request.ImportNode(GetStatus,true));
MagicalLogFile.MakeLogEntry("Requesting Job Status for Job Id: " + id);
//submit our request and get the response
SubmitRequest();
//check for a null response
if (response == null)
{
//log an error
MagicalLogFile.MakeLogEntry("Error getting Job Status for Job Id: " + id);
}
else if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "FALSE") //check that we can get a status for that job
{
//log an error
MagicalLogFile.MakeLogEntry("Could not get job status for job id: " + id + " Fault from Silverpop is: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//make a log of the status
MagicalLogFile.MakeLogEntry("Job status for jobid " + id + " is " + response.GetElementsByTagName("JOB_STATUS")[0].InnerText);
//set the job status
return(response.GetElementsByTagName("JOB_STATUS")[0].InnerText);
}
return ("ERROR");
}
}
public void WaitOnJobStatus(string id)
{
bool keepgoing=true;
string status;
}
while (keepgoing)
{
status = TGetJobStatus(id);
if (status == "COMPLETE")
{
keepgoing=false;
}
if (status == "WAITING" || jobstatus=="RUNNING")
{
//wait 30 seconds before checking again
Thread.Sleep(30000);
}
if (status == "ERROR")
{
//log the error and end the loop
MagicalLogFile.MakeLogEntry(response.FirstChild.InnerText.ToString());
keepgoing = false;
}
}
public void DeleteRecipient(Recipient r)
{
Side 47

MagicalLogFile.MakeLogEntry("Creating Delete Request for ID:" + r.Id);
//build request
request = BuildSilverpopWrapper();
XmlElement RemoveRecipient = request.CreateElement("RemoveRecipient");
request.GetElementsByTagName("Body")[0].AppendChild(RemoveRecipient);
XmlElement LIST_ID = request.CreateElement("LIST_ID");
LIST_ID.InnerText = MainListId;
RemoveRecipient.AppendChild(request.ImportNode(LIST_ID,true));
XmlElement EMAIL = request.CreateElement("EMAIL");
EMAIL.InnerText = r.Email;
RemoveRecipient.AppendChild(request.ImportNode(EMAIL,true));
XmlElement COLUMN = request.CreateElement("COLUMN");
RemoveRecipient.AppendChild(COLUMN);
//columns in here must include the name and value for any unique identifiers in the list
XmlElement NAME = request.CreateElement("NAME");
NAME.InnerText = "NEK";
COLUMN.AppendChild(NAME);
XmlElement VALUE = request.CreateElement("VALUE");
VALUE.InnerText = r.Id;
COLUMN.AppendChild(VALUE);
SubmitRequest();
//if the request was not successful record an error
if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "false")
{
MagicalLogFile.MakeLogEntry("ERROR! RemoveRecipient request returned the following fault: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//log success
MagicalLogFile.MakeLogEntry(response.FirstChild.InnerText.ToString());
}
}
}
public string JobId
{
get
{
return(jobid);
}
}
public string JobStatus
{
get
{
return(jobstatus);
}
}
public sealed class SilverpopAPIWatcher
{
private string jid;
private SilverpopAPI api;
public SilverpopAPIWatcher(string id, SilverpopAPI sapi)
Side 48

}
}
}
{
}
jid = id;
api = sapi;
public bool GetJobStatus()
{
bool keepgoing = true;
string status;
bool errors = false;
}
while (keepgoing)
{
status = api.TGetJobStatus(jid);
if (status == "COMPLETE")
{
keepgoing = false;
}
if (status == "WAITING" || status == "RUNNING")
{
//wait 30 seconds before checking again
Thread.Sleep(30000);
}
if (status == "ERROR" || status == "CANCELED")
{
//log the error and end the loop
MagicalLogFile.MakeLogEntry("Error checking job status");
keepgoing = false;
errors = true;
}
}
return (errors);
public struct Recipient
{
private string id;
private string email;
public string Id
{
get
{
return id;
}
set
{
id = value;
}
}
public string Email
{
get
{
return email;
}
set
{
email = value;
}
}
Side 49

SilverpopFTP.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Web;
using System.Net;
using System.IO;
namespace FOSS.SilverpopIntegration
{
public sealed class SilverpopFTP
{
private FtpWebResponse response;
private FtpWebRequest request;
private string username;
private string ftpurl;
private string ftppassword;
public SilverpopFTP()
{
username = System.Configuration.ConfigurationManager.AppSettings["FtpUsername"].ToString();
ftpurl = System.Configuration.ConfigurationManager.AppSettings["FtpUrl"].ToString();
ftppassword = System.Configuration.ConfigurationManager.AppSettings["FtpPassword"].ToString();
}
public void UploadList(string filename)
{
try
{
//log the upload
MagicalLogFile.MakeLogEntry("Uploading file: " + filename);
//open the file to upload
FileStream fs = File.OpenRead(System.Environment.CurrentDirectory + "\\" + filename);
//generate a byte array from file
byte[] encoded = new byte[fs.Length];
fs.Read(encoded, 0, (int)fs.Length);
fs.Close();
//convert from Unicode to UTF-8
//byte[] encoded = Encoding.Convert(Encoding.GetEncoding("Unicode"), Encoding.GetEncoding("UTF-8"), unencoded, 0,
unencoded.Length);
//set the ftp request properties
request = (FtpWebRequest)FtpWebRequest.Create(ftpurl + filename);
request.ContentLength = encoded.Length;
request.Credentials = new NetworkCredential(username, ftppassword);
request.KeepAlive = false;
//request.EnableSsl = true;
request.Method = WebRequestMethods.Ftp.UploadFile;
//upload isn't supported through http proxy, so request.proxy must be null
request.Proxy = null;
//write the file to the request stream
Stream requeststream = request.GetRequestStream();
requeststream.Write(encoded, 0, encoded.Length);
requeststream.Close();
//get the response
response = (FtpWebResponse)request.GetResponse();
MagicalLogFile.MakeLogEntry(response.StatusDescription);
}
catch(WebException ex)
{
MagicalLogFile.MakeLogEntry("A Web Exception Occured: " + ex.ToString());
throw ex;
Side 50

}
}
}
}
public void DownloadReport(string fileToGet, string fileToMake)
{
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(ftpurl + fileToGet);
request.Method = WebRequestMethods.Ftp.DownloadFile;
}
request.Credentials = new NetworkCredential(username, ftppassword);
FtpWebResponse response = (FtpWebResponse)request.GetResponse();
Stream responseStream = response.GetResponseStream();
StreamReader reader = new StreamReader(responseStream);
FileStream fs = new FileStream(fileToMake, FileMode.Create, FileAccess.Write, FileShare.None);
int length = 256;
Byte[] buffer = new Byte[length];
int bytesRead = responseStream.Read(buffer, 0, length);
while (bytesRead > 0)
{
fs.Write(buffer, 0, bytesRead);
bytesRead = responseStream.Read(buffer, 0, length);
}
responseStream.Close();
fs.Close();
/*StreamWriter sw = new StreamWriter(fs);
byte[] buffer = new byte[responseStream.Length];
sw.Write(responseStream.Read(buffer, 0, responseStream.Length));
sw.Flush();
sw.Close();
fs.Flush();
fs.Close();*/
Side 51

TransactionalDatabase.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Data.Common;
namespace FOSS.SilverpopIntegration
{
public sealed class TransactionalDatabase
{
private SqlConnection conn;
private string[] sql;
public TransactionalDatabase()
{
MagicalLogFile.MakeLogEntry("Creating Database Connection");
conn = new SqlConnection(System.Configuration.ConfigurationManager.AppSettings["FRConnection"].ToString());
}
public string[] Sql
{
get
{
return (sql);
}
set
{
sql = value;
}
}
MagicalLogFile.MakeLogEntry("SQL Commands set to:");
foreach (string s in sql)
{
MagicalLogFile.MakeLogEntry("SQL Item: " + s);
}
public void RunCommands()
{
//check for any commands to run
if (sql.Length < 1)
{
MagicalLogFile.MakeLogEntry("RunCommands() called with no SQL to run!");
return;
}
MagicalLogFile.MakeLogEntry("RunCommands() - Opening DB Connection and beginning transaction");
//open the db connection, and create a transaction
conn.Open();
SqlTransaction trans = conn.BeginTransaction();
try
{
//create the command
SqlCommand comm = new SqlCommand();
//set command properties
comm.Connection = conn;
comm.Transaction = trans;
//loop through sql commands and execute
foreach (string s in sql)
{
comm.CommandText = s;
comm.ExecuteNonQuery();
}
Side 52

}
}
}
MagicalLogFile.MakeLogEntry("Committing Transaction!");
//commit the transaction
trans.Commit();
}
catch
{
MagicalLogFile.MakeLogEntry("Transaction failed! Rolling back...");
//roll back the transaction
trans.Rollback();
}
finally
{
MagicalLogFile.MakeLogEntry("Closing DB Connection");
//close the connection
conn.Close();
}
public DataSet GetData()
{
MagicalLogFile.MakeLogEntry("Retrieving data from database");
}
//open the connection
conn.Open();
//create an sql data adapter
using (SqlDataAdapter sda = new SqlDataAdapter(sql[0], conn))
{
//create the dataset
DataSet ds = new DataSet();
}
//fill the dataset
sda.Fill(ds);
//close the connection
conn.Close();
//and return
return (ds);
Side 53

Program.cs
using System;
using System.Collections.Generic;
using System.Text;
using Ionic.Zip;
using System.IO;
using System.Data;
namespace FOSS.SilverpopIntegration
{
class Program
{
static void Main(string[] args)
{
SilverpopAPI api = new SilverpopAPI();
SilverpopFTP ftp = new SilverpopFTP();
TransactionalDatabase db = new TransactionalDatabase();
string[] sql = new string[1];
if (api.ApiLogin() == true)
{
Console.WriteLine("Successfully logged into API");
Console.Write("Running export and waiting for it to complete...");
string filename = api.RawRecipientDataExport();
Console.WriteLine("Completed");
Console.Write("Downloading report...");
ftp.DownloadReport(filename, System.Environment.CurrentDirectory + "\\" + filename);
Console.WriteLine("Done");
Console.WriteLine("Extracting files from zip");
using(ZipFile zip = ZipFile.Read(System.Environment.CurrentDirectory + "\\" + filename))
{
zip.ExtractAll(System.Environment.CurrentDirectory);
}
Console.WriteLine("done");
// Deleting Zip file
File.Delete(System.Environment.CurrentDirectory + "\\" + filename);
char[] ziptrim = { 'z', 'i', 'p' };
filename = filename.TrimEnd(ziptrim);
filename = filename + "csv";
try
{
using (FileStream csvfile = new FileStream(System.Environment.CurrentDirectory + "\\" + filename,FileMode.Open,FileAccess.Read))
{
using (TextReader csvread = new StreamReader(csvfile))
{
DataTable CsvData = CsvParser.Parse(csvread, true);
int i = 0;
byte[] TableId = null;
try
{
sql[0] = "SELECT (MAX(Silverpop_In_Id) + 1) AS nextId FROM Silverpop_In";
db.Sql = sql;
Console.WriteLine("Getting Data From Silverpop In");
using (DataSet ds = db.GetData())
{
if (ds != null)
{
DataRow dr = ds.Tables[0].Rows[0];
Side 54

}
if ("" == dr[0].ToString())
TableId = ByteConvertor.ConvertToFossBytes("1");
else
TableId = ByteConvertor.ConvertToFossBytes(dr[0].ToString());
}
else
{
MagicalLogFile.MakeLogEntry("Could not get record from Silverpop_In");
ErrorMailGenerator.SendErrorMail("Could not get record from Silverpop_In");
Environment.Exit(0);
}
}
catch (Exception ex)
{
Console.WriteLine("Failing at Getting Data");
throw new Exception(ex.Message);
}
if (CsvData.Rows.Count == 0)
Console.WriteLine("Empty dataset");
foreach (DataRow row in CsvData.Rows) // Loop over the rows.
{
}
Boolean HardBounce = false;
Boolean SoftBounce = false;
Boolean Opened = false;
Boolean Clicked = false;
Boolean OptIn = false;
Boolean OptOut = false;
switch (row["Event Type"].ToString())
{
case "Open" :
Opened = true;
break;
case "Click Through" :
Clicked = true;
break;
case "Soft Bounce":
SoftBounce = true;
break;
case "Hard Bounce":
HardBounce = true;
break;
case "Opt In":
OptIn = true;
break;
case "Opt Out":
OptOut = true;
break;
}
sql[i] = @"INSERT INTO [Silverpop_In]
([Silverpop_In_Id], [Rn_Create_Date], [Contact_Id], [Email], [Email_Opt_In], [Email_Opt_Out],
[Email_Bounced_Hard], [Email_Bounced_Soft], [Email_Bounced_Date], [Email_Clicked], [Email_Clicked_Date],
[Email_Clicked_Link], [Mailing_Description], [Email_Opened], [Email_Opened_Date])
VALUES
(" + TableId + ", " + DateTime.Now.ToString() + ", " + row["Contact Id"] + ", " + row["Email"] + ", " + OptIn
+ ", " + OptOut + ", " + HardBounce + ", " + SoftBounce +", " + row["Event Timestamp"] + ", " + Clicked
+ ", " + row["Event Timestamp"] + ", " + row["URL"] + ", " + row["Mailing Id"] + ", " + Opened + ", " +
row["Event Timestamp"];
i++;
Side 55

}
}
}
db.Sql = sql;
}
}
}
catch (IOException)
{
MagicalLogFile.MakeLogEntry("There was an error when trying to read from csv file");
Environment.Exit(0);
}
}
else
{
Console.WriteLine("Could not log in to API");
MagicalLogFile.MakeLogEntry("Could not log in to API");
}
Console.WriteLine("Press ENTER to exit...");
Console.ReadLine();
Side 56

ConsoleApplication1 C#
App.config
Side 57

ByteConvertor.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace FOSS.SilverpopIntegration
{
public static class ByteConvertor
{
///
/// Converts an decimal id into an bytearray id
///
/// The decimal representation of the id
/// The Bytearray representation of the id.
public static byte[] ConvertToFossBytes(string id)
{
byte[] converted = new byte[8];
string binstring = "";
}
if (id.Contains("-"))
{
string[] num = id.Split('-');
binstring = DecimalToBase(Convert.ToInt32(num[0]), 2).PadLeft(24, '0');
binstring += DecimalToBase(Convert.ToInt32(num[1]), 2).PadLeft(40, '0');
}
else
{
binstring = DecimalToBase(Convert.ToInt32(id), 2).PadLeft(64, '0');
}
for (int i = 0; i < converted.Length; i++)
{
converted[i] = (byte)BinToDecimal(binstring.Substring(i * 8, 8));
}
return converted;
///
/// Converts a bytearray representation of an id into a decimal representation of the id
///
/// bytearray representation of the id
/// the decimal representation of the id
public static string ConvertFossBytes(byte[] workid)
{
string[] BinStringArr = new string[workid.Length];
for (int i = 0; i < workid.Length; i++)
{
BinStringArr[i] = DecimalToBase(workid[i], 2).PadLeft(8, '0');
}
string Head = "";
string Tail = "";
Head = BinStringArr[0];
Head += BinStringArr[1];
Head += BinStringArr[2];
Tail = BinStringArr[3];
Tail += BinStringArr[4];
Tail += BinStringArr[5];
Tail += BinStringArr[6];
Tail += BinStringArr[7];
string HeadOut = BinToDecimal(Head).ToString();
string TailOut = BinToDecimal(Tail).ToString();
Side 58

}
}
}
if (HeadOut == "0")
return TailOut;
else
return HeadOut + "-" + TailOut;
///
/// Converts a decimal representation of a number into the "base" representation of the number
///
/// The decimal number
/// The base that the the decimal should be converted into
/// The converted number
public static string DecimalToBase(int iDec, int numbase)
{
string strBin = "";
int[] result = new int[32];
int MaxBit = 32;
for (; iDec > 0; iDec /= numbase)
{
int rem = iDec % numbase;
result[--MaxBit] = rem;
}
for (int i = 0; i < result.Length; i++)
{
strBin += result.GetValue(i);
}
strBin = strBin.TrimStart(new char[] { '0' });
return strBin;
}
///
/// Converts from binary to decimal
///
/// binary representation of the number
/// the decimal representation of the number
public static int BinToDecimal(string sBase)
{
int dec = 0;
int bit = 0;
for (int i = sBase.Length - 1; i >= 0; i--)
{
if ("1" == sBase[i].ToString())
{
dec += (int)Math.Pow(2, bit);
}
bit++;
}
return dec;
}
Side 59

CsvFileGenerator.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Data;
using System.Data.SqlClient;
using System.Data.Common;
using System.Text.RegularExpressions;
namespace FOSS.SilverpopIntegration
{
public sealed class CsvFileGenerator
{
private string filename;
public string FileName
{
get
{
return (filename);
}
set
{
filename = value;
MagicalLogFile.MakeLogEntry("Filename changed to: " + filename);
}
}
public void CreateMainFile(DataRow dr)
{
StreamWriter sw = File.AppendText(filename);
try
{
try
{
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Contact_Id"])));
}
catch
{
sw.Write(FormatForCSV(""));
}
try
{
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Lead_Id"])));
}
catch
{
sw.Write(FormatForCSV(""));
}
sw.Write(FormatForCSV(dr["First_Name"].ToString()));
sw.Write(FormatForCSV(dr["Last_Name"].ToString()));
sw.Write(FormatForCSV(dr["Job_Category"].ToString()));
sw.Write(FormatForCSV(dr["Country"].ToString()));
sw.Write(FormatForCSV(dr["E_Mail"].ToString()));
try
{
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Company_Id"])));
}
catch
{
sw.Write(FormatForCSV(""));
}
sw.Write(FormatForCSV(dr["Company_Name"].ToString()));
sw.Write(FormatForCSV(dr["RSM_First_Name"].ToString()));
sw.Write(FormatForCSV(dr["RSM_Last_Name"].ToString()));
Side 60

}
sw.Write(FormatForCSV(dr["RSM_Job_Title"].ToString()));
sw.Write(FormatForCSV(dr["RSM_Company_Name"].ToString()));
sw.Write(FormatForCSV(dr["RSM_E_Mail"].ToString()));
sw.Write(FormatForCSV(dr["RSM_Phone"].ToString()));
sw.Write(FormatForCSV(dr["BA_Analytical_Labs"].ToString()));
sw.Write(FormatForCSV(dr["BA_Beer"].ToString()));
sw.Write(FormatForCSV(dr["BA_Biofuel"].ToString()));
sw.Write(FormatForCSV(dr["BA_Chemicals"].ToString()));
sw.Write(FormatForCSV(dr["BA_Confectionery"].ToString()));
sw.Write(FormatForCSV(dr["BA_Dressings"].ToString()));
sw.Write(FormatForCSV(dr["BA_Edible_Oils"].ToString()));
sw.Write(FormatForCSV(dr["BA_Feed_and_Forage"].ToString()));
sw.Write(FormatForCSV(dr["BA_Flour"].ToString()));
sw.Write(FormatForCSV(dr["BA_Grain"].ToString()));
sw.Write(FormatForCSV(dr["BA_Meat"].ToString()));
sw.Write(FormatForCSV(dr["BA_Microbiology"].ToString()));
sw.Write(FormatForCSV(dr["BA_Milk_and_Dairy"].ToString()));
sw.Write(FormatForCSV(dr["BA_Pet_Food"].ToString()));
sw.Write(FormatForCSV(dr["BA_Pharmaceuticals"].ToString()));
sw.Write(FormatForCSV(dr["BA_Sugar"].ToString()));
sw.Write(FormatForCSV(dr["BA_Water_and_Soil"].ToString()));
sw.Write(FormatForCSV(dr["BA_Wine"].ToString()));
string part1 = null;
string part2 = null;
try
{
part1 = ByteConvertor.ConvertFossBytes((byte[])dr["Contact_Id"]);
}
catch
{
part2 = ByteConvertor.ConvertFossBytes((byte[])dr["Lead_Id"]);
}
finally
{
sw.WriteLine(FormatForCSV(part1 + part2,true));
}
}
finally
{
sw.Close();
}
public void CreateProductFile(DataRow dr)
{
StreamWriter sw = File.AppendText(filename);
try
{
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Registration_Id"])));
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Company_Id"])));
sw.Write(FormatForCSV(dr["Product_Name"].ToString()));
sw.WriteLine(FormatForCSV(dr["Product_Group_Name"].ToString(), true));
}
finally
{
sw.Close();
}
}
public void CreateBAFile(DataRow dr)
{
StreamWriter sw = File.AppendText(filename);
try
{
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Contact_Customer_Segment_Id"])));
Side 61

}
try
{
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Contact_Id"])));
}
catch
{
sw.Write(FormatForCSV(""));
}
try
{
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Lead_Id"])));
}
catch
{
sw.Write(FormatForCSV(""));
}
sw.WriteLine(FormatForCSV(dr["Segment"].ToString(), true));
}
finally
{
sw.Close();
}
public void CreatePrefCommFile(DataRow dr)
{
StreamWriter sw = File.AppendText(filename);
try
{
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Preferred_Com_Methods_Id"])));
try
{
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Contact_Id"])));
}
catch
{
sw.Write(FormatForCSV(""));
}
try
{
sw.Write(FormatForCSV(ByteConvertor.ConvertFossBytes((byte[])dr["Lead__Id"])));
}
catch
{
sw.Write(FormatForCSV(""));
}
}
sw.WriteLine(FormatForCSV(dr["Type"].ToString(), true));
}
finally
{
sw.Close();
}
public void DeleteFile()
{
try
{
File.Delete(filename);
}
catch (Exception ex)
{
MagicalLogFile.MakeLogEntry("Unable To Delete File! " + ex.ToString());
}
Side 62

}
}
}
private string FormatForCSV(string s, bool last)
{
//escape any speech marks in the string
string pattern = "\"";
}
Regex regex = new Regex(pattern);
Match match = regex.Match(s);
s = regex.Replace(s, "\"\"");
//if this is the last item in a row, omit the trailing comma
if (last)
{
return ("\"" + s + "\"");
}
else
{
return ("\"" + s + "\",");
}
private string FormatForCSV(string s)
{
return(FormatForCSV(s, false));
}
Side 63

SilverpopAPI.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Configuration;
using System.Web;
using System.Net;
using System.IO;
using System.Threading;
namespace FOSS.SilverpopIntegration
{
public sealed class SilverpopAPI
{
private string sessionid;
private string sessionencoding;
private XmlDocument request;
private XmlDocument response;
private string jobstatus;
private string url;
private string username;
private string password;
private string jobid;
private static string MainListId = System.Configuration.ConfigurationManager.AppSettings["MainListId"].ToString();
public SilverpopAPI()
{
url = System.Configuration.ConfigurationManager.AppSettings["ApiUrl"].ToString();
username = System.Configuration.ConfigurationManager.AppSettings["Username"].ToString();
password = System.Configuration.ConfigurationManager.AppSettings["Password"].ToString();
}
request = new XmlDocument();
response = new XmlDocument();
public bool ApiLogin()
{
if (sessionid == null)
{
//create xml document
request = BuildSilverpopWrapper();
XmlElement Login = request.CreateElement("Login");
request.GetElementsByTagName("Body")[0].AppendChild(Login);
//add username and password from app.config
XmlElement usernameXML = request.CreateElement("USERNAME");
usernameXML.InnerText = username;
Login.AppendChild(usernameXML);
XmlElement passwordXML = request.CreateElement("PASSWORD");
passwordXML.InnerText = password;
Login.AppendChild(passwordXML);
//logging in
MagicalLogFile.MakeLogEntry("Logging Into Silverpop API...");
SubmitRequest();
if (response == null) return (false);
//parse the response to check if logged in, and get the sessionid
if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "true")
{
sessionid = response.GetElementsByTagName("SESSIONID")[0].InnerText;
sessionencoding = response.GetElementsByTagName("SESSION_ENCODING")[0].InnerText;
Side 64

}
MagicalLogFile.MakeLogEntry("Successfully logged in with sessionid: " + sessionid);
return (true);
}
else
{
//log an error
MagicalLogFile.MakeLogEntry("Failed to login to API :: " + response.GetElementsByTagName("FaultString")[0].InnerText);
}
return (false);
}
else
{
//already logged in
MagicalLogFile.MakeLogEntry("Already logged into Silverpop API");
return (true);
}
public void ApiLogout()
{
if (sessionid == null)
{
//not logged in it seems
MagicalLogFile.MakeLogEntry("Already logged out of API");
//ensure variables are reset
sessionencoding = null;
}
else
{
//create logout request
request = BuildSilverpopWrapper();
}
}
XmlElement logout = request.CreateElement("Logout");
request.GetElementsByTagName("Body")[0].AppendChild(logout);
//logging out
MagicalLogFile.MakeLogEntry("Logging out of API");
//submit request and get response
SubmitRequest();
if (response == null)
{
MagicalLogFile.MakeLogEntry("Null response when attempting to log out");
}
sessionencoding = null;
sessionid = null;
private XmlDocument BuildSilverpopWrapper()
{
XmlDocument xml = new XmlDocument();
XmlDeclaration xmlDec = xml.CreateXmlDeclaration("1.0", "utf-8", null);
XmlElement envelope = xml.CreateElement("Envelope");
xml.InsertBefore(xmlDec, xml.DocumentElement);
xml.AppendChild(envelope);
XmlElement body = xml.CreateElement("Body");
envelope.AppendChild(body);
return (xml);
Side 65

}
public void ListImport(string list)
{
if (sessionid == null)
{
MagicalLogFile.MakeLogEntry("Attempted to make an API Request without being logged in!");
}
else
{
//build our request
request = BuildSilverpopWrapper();
XmlElement ImportList_ = request.CreateElement("ImportList");
request.GetElementsByTagName("Body")[0].AppendChild(ImportList_);
XmlElement MAP_FILE = request.CreateElement("MAP_FILE");
MAP_FILE.InnerText = list + ".xml";
ImportList_.AppendChild(MAP_FILE);
XmlElement SOURCE_FILE = request.CreateElement("SOURCE_FILE");
SOURCE_FILE.InnerText = list + ".csv";
ImportList_.AppendChild(SOURCE_FILE);
//log the request
MagicalLogFile.MakeLogEntry("Sending ListImport Request to Silverpop API for list: " + list);
//make the request and get response
SubmitRequest();
//if the request was not successful record an error
if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "false")
{
MagicalLogFile.MakeLogEntry("ERROR! ListImport request returned the following fault: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//log success
MagicalLogFile.MakeLogEntry(response.FirstChild.InnerText.ToString());
jobid = response.GetElementsByTagName("JOB_ID")[0].InnerText;
}
}
}
public void TableImport(string list)
{
if (sessionid == null)
{
MagicalLogFile.MakeLogEntry("Attempted to make an API Request without being logged in!");
}
else
{
//build our request
request = BuildSilverpopWrapper();
XmlElement ImportTable_ = request.CreateElement("ImportTable");
request.GetElementsByTagName("Body")[0].AppendChild(ImportTable_);
XmlElement MAP_FILE = request.CreateElement("MAP_FILE");
MAP_FILE.InnerText = list + ".xml";
ImportTable_.AppendChild(MAP_FILE);
XmlElement SOURCE_FILE = request.CreateElement("SOURCE_FILE");
SOURCE_FILE.InnerText = list + ".csv";
ImportTable_.AppendChild(SOURCE_FILE);
//log the request
Side 66

MagicalLogFile.MakeLogEntry("Sending TableImport Request to Silverpop API for list: " + list);
//make the request and get response
SubmitRequest();
//if the request was not successful record an error
if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "false")
{
MagicalLogFile.MakeLogEntry("ERROR! TableImport request returned the following fault: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//log success
MagicalLogFile.MakeLogEntry(response.FirstChild.InnerText.ToString());
jobid = response.GetElementsByTagName("JOB_ID")[0].InnerText;
}
}
}
private void SubmitRequest()
{
//build a webrequest
WebRequest wrequest = WebRequest.Create(url + sessionencoding) as HttpWebRequest;
}
//set request properties
wrequest.ContentType = "text/xml;charset=UTF-8";
wrequest.Method = "POST";
StringWriter sw = new StringWriter();
XmlTextWriter xw = new XmlTextWriter(sw);
//save the xml request to a text writer
request.WriteTo(xw);
System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
//convert to a byte array
byte[] byteData = encoding.GetBytes(HttpUtility.UrlPathEncode(sw.ToString()));
wrequest.ContentLength = byteData.Length;
//add data to the request
using (Stream requestStream = wrequest.GetRequestStream())
{
requestStream.Write(byteData, 0, byteData.Length);
}
//finish the request
wrequest.GetRequestStream().Close();
//get the response
HttpWebResponse wresponse = (HttpWebResponse)wrequest.GetResponse();
//load the response into the response xmlDoc
response = new XmlDocument();
try
{
response.Load(wresponse.GetResponseStream());
}
catch (Exception)
{
//log an error
MagicalLogFile.MakeLogEntry("ERROR while making a request to the Silverpop API - Response could not be loaded!");
}
private void GetJobStatus()
Side 67

{
if (sessionid == null)
{
//not logged in
MagicalLogFile.MakeLogEntry("Can't get a job status, not logged in");
}
else
{
//build our request
request = BuildSilverpopWrapper();
XmlElement GetStatus = request.CreateElement("GetJobStatus");
request.GetElementsByTagName("Body")[0].AppendChild(GetStatus);
XmlElement JOB_ID = request.CreateElement("JOB_ID");
JOB_ID.InnerText = jobid;
GetStatus.AppendChild(JOB_ID);
//submit our request and get the response
SubmitRequest();
//check for a null response
if (response == null)
{
//log an error
MagicalLogFile.MakeLogEntry("Error getting Job Status for Job Id: " + jobid);
}
else if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "FALSE") //check that we can get a status for that job
{
//log an error
MagicalLogFile.MakeLogEntry("Could not get job status for job id: " + jobid + " Fault from Silverpop is: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//set the job status
jobstatus = response.GetElementsByTagName("JOB_STATUS")[0].InnerText;
//make a log of the status
MagicalLogFile.MakeLogEntry("Job status for jobid " + jobid + " is " + jobstatus);
}
}
}
public string TGetJobStatus(string id)
{
if (sessionid == null)
{
//not logged in
MagicalLogFile.MakeLogEntry("Can't get a job status, not logged in");
return ("ERROR");
}
else
{
request = null;
//build our request
request = BuildSilverpopWrapper();
XmlElement GetStatus = request.CreateElement("GetJobStatus");
XmlElement JOB_ID = request.CreateElement("JOB_ID");
JOB_ID.InnerText = id;// (string)Thread.GetData(loc);
GetStatus.AppendChild(request.ImportNode(JOB_ID, true));
request.GetElementsByTagName("Body")[0].AppendChild(request.ImportNode(GetStatus,true));
MagicalLogFile.MakeLogEntry("Requesting Job Status for Job Id: " + id);
//submit our request and get the response
SubmitRequest();
Side 68

check for a null response
if (response == null)
{
//log an error
MagicalLogFile.MakeLogEntry("Error getting Job Status for Job Id: " + id);
}
else if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "FALSE") //check that we can get a status for that job
{
//log an error
MagicalLogFile.MakeLogEntry("Could not get job status for job id: " + id + " Fault from Silverpop is: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//make a log of the status
MagicalLogFile.MakeLogEntry("Job status for jobid " + id + " is " + response.GetElementsByTagName("JOB_STATUS")[0].InnerText);
//set the job status
return(response.GetElementsByTagName("JOB_STATUS")[0].InnerText);
}
return ("ERROR");
}
}
public void WaitOnJobStatus(string id)
{
bool keepgoing=true;
string status;
}
//LocalDataStoreSlot localSlot = Thread.AllocateDataSlot();
//Thread.SetData(localSlot, id);
while (keepgoing)
{
status = TGetJobStatus(id);
if (status == "COMPLETE")
{
keepgoing=false;
}
if (status == "WAITING" || jobstatus=="RUNNING")
{
//wait 30 seconds before checking again
Thread.Sleep(30000);
}
if (status == "ERROR")
{
//log the error and end the loop
MagicalLogFile.MakeLogEntry(response.FirstChild.InnerText.ToString());
keepgoing = false;
}
}
public void DeleteRecipient(Recipient r)
{
MagicalLogFile.MakeLogEntry("Creating Delete Request for ID:" + r.Id);
//build request
request = BuildSilverpopWrapper();
XmlElement RemoveRecipient = request.CreateElement("RemoveRecipient");
request.GetElementsByTagName("Body")[0].AppendChild(RemoveRecipient);
XmlElement LIST_ID = request.CreateElement("LIST_ID");
LIST_ID.InnerText = MainListId;
RemoveRecipient.AppendChild(request.ImportNode(LIST_ID,true));
XmlElement EMAIL = request.CreateElement("EMAIL");
EMAIL.InnerText = r.Email;
Side 69

RemoveRecipient.AppendChild(request.ImportNode(EMAIL,true));
XmlElement COLUMN = request.CreateElement("COLUMN");
RemoveRecipient.AppendChild(COLUMN);
//columns in here must include the name and value for any unique identifiers in the list
XmlElement NAME = request.CreateElement("NAME");
NAME.InnerText = "NEK";
COLUMN.AppendChild(NAME);
XmlElement VALUE = request.CreateElement("VALUE");
VALUE.InnerText = r.Id;
COLUMN.AppendChild(VALUE);
SubmitRequest();
//if the request was not successful record an error
if (response.GetElementsByTagName("SUCCESS")[0].InnerText == "false")
{
MagicalLogFile.MakeLogEntry("ERROR! RemoveRecipient request returned the following fault: " +
response.GetElementsByTagName("FaultString")[0].InnerText);
}
else
{
//log success
MagicalLogFile.MakeLogEntry(response.FirstChild.InnerText.ToString());
}
}
}
public string JobId
{
get
{
return(jobid);
}
}
public string JobStatus
{
get
{
return(jobstatus);
}
}
public sealed class SilverpopAPIWatcher
{
private string jid;
private SilverpopAPI api;
public SilverpopAPIWatcher(string id, SilverpopAPI sapi)
{
jid = id;
api = sapi;
}
public bool GetJobStatus()
{
bool keepgoing = true;
string status;
bool errors = false;
while (keepgoing)
{
status = api.TGetJobStatus(jid);
Side 70

}
}
}
}
}
if (status == "COMPLETE")
{
keepgoing = false;
}
if (status == "WAITING" || status == "RUNNING")
{
//wait 30 seconds before checking again
Thread.Sleep(30000);
}
if (status == "ERROR" || status == "CANCELED")
{
//log the error and end the loop
MagicalLogFile.MakeLogEntry("Error checking job status");
keepgoing = false;
errors = true;
}
return (errors);
public struct Recipient
{
private string id;
private string email;
public string Id
{
get
{
return id;
}
set
{
id = value;
}
}
public string Email
{
get
{
return email;
}
set
{
email = value;
}
}
Side 71

SilverpopFTP.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Web;
using System.Net;
using System.IO;
namespace FOSS.SilverpopIntegration
{
public sealed class SilverpopFTP
{
private FtpWebResponse response;
private FtpWebRequest request;
private string username;
private string ftpurl;
private string ftppassword;
public SilverpopFTP()
{
username = System.Configuration.ConfigurationManager.AppSettings["FtpUsername"].ToString();
ftpurl = System.Configuration.ConfigurationManager.AppSettings["FtpUrl"].ToString();
ftppassword = System.Configuration.ConfigurationManager.AppSettings["FtpPassword"].ToString();
}
public void UploadList(string filename)
{
try
{
//log the upload
MagicalLogFile.MakeLogEntry("Uploading file: " + filename);
//open the file to upload
FileStream fs = File.OpenRead(System.Environment.CurrentDirectory + "\\" + filename);
//generate a byte array from file
byte[] encoded = new byte[fs.Length];
fs.Read(encoded, 0, (int)fs.Length);
fs.Close();
//convert from Unicode to UTF-8
//byte[] encoded = Encoding.Convert(Encoding.GetEncoding("Unicode"), Encoding.GetEncoding("UTF-8"), unencoded, 0,
unencoded.Length);
//set the ftp request properties
request = (FtpWebRequest)FtpWebRequest.Create(ftpurl + filename);
request.ContentLength = encoded.Length;
request.Credentials = new NetworkCredential(username, ftppassword);
request.KeepAlive = false;
//request.EnableSsl = true;
request.Method = WebRequestMethods.Ftp.UploadFile;
//upload isn't supported through http proxy, so request.proxy must be null
request.Proxy = null;
//write the file to the request stream
Stream requeststream = request.GetRequestStream();
requeststream.Write(encoded, 0, encoded.Length);
requeststream.Close();
//get the response
response = (FtpWebResponse)request.GetResponse();
MagicalLogFile.MakeLogEntry(response.StatusDescription);
}
catch(WebException ex)
{
MagicalLogFile.MakeLogEntry("A Web Exception Occured: " + ex.ToString());
throw ex;
Side 72

}
}
}
}
Side 73

Program.cs
using System;
using System.Collections.Generic;
using System.Text;
using FOSS.SilverpopIntegration;
using System.Data;
using System.Threading;
using System.IO;
namespace FOSS.SilverpopIntegration
{
class SilverpopSync
{
static void Main(string[] args)
{
TransactionalDatabase db = new TransactionalDatabase();
CsvFileGenerator csv = new CsvFileGenerator();
SilverpopFTP ftp = new SilverpopFTP();
SilverpopAPI api = new SilverpopAPI();
int NUMBER_OF_FILES = 4;
string[] sql = new string[1];
#region deletions
//run through all delete requests
sql[0] = "SELECT * FROM Silverpop_Out WHERE Deletion = 1";
db.Sql = sql;
Console.WriteLine("Getting Deletion Records");
using (DataSet ds = db.GetData())
{
if (ds != null)
{
if (ds.Tables[0].Rows.Count == 0)
{
Console.WriteLine("There are no deletions");
MagicalLogFile.MakeLogEntry("There are no deletions");
}
else
{
if (api.ApiLogin())
{
Console.WriteLine("Starting Deletions...");
List events = new List();
foreach (DataRow dr in ds.Tables[0].Rows)
{
Recipient r = new Recipient();
string part1 = null;
string part2 = null;
try
{
part1 = ByteConvertor.ConvertFossBytes((byte[])dr["Contact_Id"]);
}
catch
{
part2 = ByteConvertor.ConvertFossBytes((byte[])dr["Lead_Id"]);
}
finally
{
r.Id = part1 + part2;
}
r.Email = dr["E_Mail"].ToString();
ManualResetEvent mre = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(
delegate(object o)
Side 74

{
api.DeleteRecipient(r);
((ManualResetEvent)o).Set();
}, mre);
events.Add(mre);
}
Console.Write("Waiting for delete requests to be submitted...");
WaitHandle.WaitAll(events.ToArray());
Console.WriteLine("Done!");
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("ERROR LOGGING INTO API - CHECK USERNAME AND PASSWORD");
//send an error mail
ErrorMailGenerator.SendErrorMail("Couldn't log into the api, check username and password");
Environment.Exit(0);
}
}
}
else
{
Console.WriteLine("Couldn't get deletions data");
MagicalLogFile.MakeLogEntry("Couldn't get any deletions data...");
}
}
#endregion
#region MainList
//create and upload MainList
csv.FileName = System.Environment.CurrentDirectory + "\\MainList.csv";
sql[0] = "SELECT * FROM Silverpop_Out WHERE Deletion=0";
db.Sql = sql;
Console.WriteLine("Getting Data");
using (DataSet ds = db.GetData())
{
if (ds != null)
{
if (ds.Tables[0].Rows.Count == 0)
{
Console.WriteLine("Empty Mainlist Dataset, exiting program");
MagicalLogFile.MakeLogEntry("Empty Mainlist Dataset, exiting program");
Environment.Exit(0);
}
Console.WriteLine("Making file");
foreach (DataRow dr in ds.Tables["Table"].Rows)
{
csv.CreateMainFile(dr);
}
Console.WriteLine("Uploading File");
ftp.UploadList("MainList.csv");
ftp.UploadList("MainList.xml");
csv.DeleteFile();
}
else
{
MagicalLogFile.MakeLogEntry("Could not get dataset when attempting to retrieve mainlist");
ErrorMailGenerator.SendErrorMail("Could not get dataset when attempting to retrieve mainlist");
Environment.Exit(0);
}
Side 75

}
#endregion
#region Products
//Create and upload Products
csv.FileName = System.Environment.CurrentDirectory + "\\products.csv";
sql[0] = @"SELECT DISTINCT Registration.Registration_Id, Registration.Company_Id, Registration.Product_Name,
Product_Group.Product_Group_Name
FROM Silverpop_Out, Registration, Product_Group, Product
WHERE Silverpop_Out.Company_Id = Registration.Company_Id
AND Registration.Product_Id = Product.Product_Id
AND Product.Product_Group_Id = Product_Group.Product_Group_Id
AND Registration.Formerly_Installed = 0";
db.Sql = sql;
Console.WriteLine("Getting Data");
using (DataSet ds = db.GetData())
{
if (ds != null)
{
Console.WriteLine("Making file");
foreach (DataRow dr in ds.Tables["Table"].Rows)
{
csv.CreateProductFile(dr);
}
Console.WriteLine("Uploading File");
if (File.Exists(System.Environment.CurrentDirectory + "\\products.csv"))
{
ftp.UploadList("products.csv");
ftp.UploadList("products.xml");
csv.DeleteFile();
}
else
{
Console.WriteLine("Products not uploaded - file does not exist");
MagicalLogFile.MakeLogEntry("Products not uploaded - file does not exist");
}
}
else
{
MagicalLogFile.MakeLogEntry("Could not get dataset when attempting to retrieve products");
ErrorMailGenerator.SendErrorMail("Could not get dataset when attempting to retrieve products");
}
}
#endregion
#region Business Areas
//Create and upload BA
csv.FileName = System.Environment.CurrentDirectory + "\\ba.csv";
sql[0] = @"SELECT Contact_Customer_Segment.Contact_Customer_Segment_Id, Silverpop_Out.Contact_Id, Silverpop_Out.Lead_Id,
Contact_Customer_Segment.Segment
FROM Contact_Customer_Segment, Silverpop_Out
WHERE Contact_Customer_Segment.Contact_Id = Silverpop_Out.Contact_Id
OR Contact_Customer_Segment.Lead_Id = Silverpop_Out.Lead_Id";
db.Sql = sql;
Console.WriteLine("Getting Data");
using (DataSet ds = db.GetData())
{
if (ds != null)
{
Console.WriteLine("Making file");
foreach (DataRow dr in ds.Tables["Table"].Rows)
Side 76

{
csv.CreateBAFile(dr);
}
Console.WriteLine("Uploading File");
if (File.Exists(System.Environment.CurrentDirectory + "\\ba.csv"))
{
ftp.UploadList("ba.csv");
ftp.UploadList("ba.xml");
csv.DeleteFile();
}
else
{
Console.WriteLine("BA not uploaded - file does not exist");
MagicalLogFile.MakeLogEntry("BA not uploaded - file does not exist");
}
}
else
{
MagicalLogFile.MakeLogEntry("Could not get dataset when attempting to retrieve business areas");
ErrorMailGenerator.SendErrorMail("Could not get dataset when attempting to retrieve business areas");
}
}
#endregion
#region Pref Comm Methods
csv.FileName = System.Environment.CurrentDirectory + "\\pref_comm.csv";
sql[0] = @"SELECT Preferred_Com_Methods.Preferred_Com_Methods_Id, Preferred_Com_Methods.Contact_Id,
Preferred_Com_Methods.Lead__Id, Preferred_Com_Methods.Type
FROM Preferred_Com_Methods, Silverpop_Out
WHERE Preferred_Com_Methods.Contact_Id = Silverpop_Out.Contact_Id
OR Preferred_Com_Methods.Lead__Id = Silverpop_Out.Lead_Id";
db.Sql = sql;
Console.WriteLine("Getting Data");
using (DataSet ds = db.GetData())
{
if (ds != null)
{
Console.WriteLine("Making file");
foreach (DataRow dr in ds.Tables["Table"].Rows)
{
csv.CreatePrefCommFile(dr);
}
Console.WriteLine("Uploading File");
if (File.Exists(System.Environment.CurrentDirectory + "\\pref_comm.csv"))
{
ftp.UploadList("pref_comm.csv");
ftp.UploadList("pref_comm.xml");
csv.DeleteFile();
}
else
{
Console.WriteLine("pref comms not uploaded - file does not exist");
MagicalLogFile.MakeLogEntry("pref comms not uploaded - file does not exist");
}
}
else
{
MagicalLogFile.MakeLogEntry("Could not get dataset when attempting to retrieve Preferred Communication Methods");
ErrorMailGenerator.SendErrorMail("Could not get dataset when attempting to retrieve Preferred Communication Methods");
}
}
#endregion
Side 77

String[] jobids = new String[NUMBER_OF_FILES];
if (api.ApiLogin())
{
Console.WriteLine("Successfully logged into silverpop api");
#region Start Imports
//start the imports and get job ids
Console.WriteLine("Attempting to import: MainList");
api.ListImport("MainList");
jobids[0] = api.JobId;
Console.WriteLine("Job ID for import is: {0}", api.JobId);
Console.WriteLine("Attempting to import: products");
api.TableImport("products");
jobids[1] = api.JobId;
Console.WriteLine("Job ID for import is: {0}", api.JobId);
Console.WriteLine("Attempting to import: ba");
api.TableImport("ba");
jobids[2] = api.JobId;
Console.WriteLine("Job ID for import is: {0}", api.JobId);
Console.WriteLine("Attempting to import: pref comms");
api.TableImport("pref_comm");
jobids[3] = api.JobId;
Console.WriteLine("Job ID for import is: {0}", api.JobId);
#endregion
//start a threadpool to wait for each import to complete
List events = new List();
bool started = false;
bool errorsEncountered = false;
foreach (string i in jobids)
{
started = false;
}
Console.WriteLine("Item added to threadpool for jobid: " + i);
ManualResetEvent mre = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(
delegate(object o)
{
SilverpopAPIWatcher apiw = new SilverpopAPIWatcher(i, api);
started = true;
if (apiw.GetJobStatus() == true) errorsEncountered = true;
((ManualResetEvent)o).Set();
},mre);
events.Add(mre);
while (!started)
{
Console.WriteLine("It's not ready yet");
}
Console.WriteLine("All Items added, waiting for imports to finish...");
WaitHandle.WaitAll(events.ToArray());
if (errorsEncountered)
{
MagicalLogFile.MakeLogEntry("Errors were encountered during API Import Operations, earlier log entries should include more
information");
ErrorMailGenerator.SendErrorMail("Errors were encountered during API Import Operations, earlier log entries should include more
information");
Environment.Exit(0);
}
api.ApiLogout();
Console.WriteLine("Emptying Silverpop_Out Table");
Side 78

}
}
}
sql[0] = "TRUNCATE TABLE Silverpop_Out";
db.Sql = sql;
db.RunCommands();
//Console.WriteLine("Press Enter to exit...");
//Console.ReadLine();
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("ERROR LOGGING INTO API - CHECK USERNAME AND PASSWORD");
}
//send an error mail
ErrorMailGenerator.SendErrorMail("Couldn't log into the api, please check the username and password");
Environment.Exit(0);
Side 79

MainList.xml
ADD_AND_UPDATE
6834860
1
0
Contact Id
0
Lead Id
0
First Name
0
Last Name
0
Job Category
0
Country
0
EMAIL
9
true
Company Id
0
Company Name
0
RSM First Name
0
RSM Last Name
0
RSM Job Title
0
RSM Company
0
RSM EMail
0
Side 80

RSM Phone
0
BA Analytical Labs
0
BA Beer
0
BA Biofuel
0
BA Chemicals
0
BA Confectionery
0
BA Dressings and Condiments
0
BA Edible Oils and Fats
0
BA Feed and Forage
0
BA Flour
0
BA Grain
0
BA Meat
0
BA Microbiology
0
BA Milk and Dairy
0
BA Pet Food
0
BA Pharmaceutical
0
BA Sugar
0
Side 81

BA Water and Soil
0
BA Wine
0
NEK
0
true
true
1
Contact Id
true
2
Lead Id
true
3
First Name
true
4
Last Name
true
5
Job Category
true
6
Country
true
7
EMAIL
true
8
Company Id
true
9
Company Name
true
10
RSM First Name
true
11
RSM Last Name
Side 82

true
12
RSM Job Title
true
13
RSM Company
true
14
RSM EMail
true
15
RSM Phone
true
16
BA Analytical Labs
true
17
BA Beer
true
18
BA Biofuel
true
19
BA Chemicals
true
20
BA Confectionery
true
21
BA Dressings and Condiments
true
22
BA Edible Oils and Fats
true
23
BA Feed and Forage
true
24
BA Flour
true
Side 83

25
BA Grain
true
26
BA Meat
true
27
BA Microbiology
true
28
BA Milk and Dairy
true
29
BA Pet Food
true
30
BA Pharmaceutical
true
31
BA Sugar
true
32
BA Water and Soil
true
33
BA Wine
true
34
NEK
true
Side 84