Merge dbf54a3 into b78eae0

src/app/inbox/inbox-messages/inbox-messages.component.html

@@ -41,7 +41,29 @@
           </div>
         </td>
         <td class="d-none d-md-block" (click)="openMail(mail,messagesTable.attributes['data-value'].value)">
-          {{mail.headers.from}}</td>
+
+          <!-- Name defined -->
+          <span *ngIf="messagesNameRecords[parseAddressFromMailchain(mail.headers.from)] != undefined">
+
+            <span class="resolved-name">{{messagesNameRecords[parseAddressFromMailchain(mail.headers.from)]}}</span>
+
+            <br>
+
+            <span class="resolved-address text-muted">{{mail.headers.from}}</span>
+
+          </span>
+          <!-- ./ Name defined -->
+
+          <!-- Name not defined -->
+          <span class="unresolved-address"
+            *ngIf="messagesNameRecords[parseAddressFromMailchain(mail.headers.from)] == undefined" 
+            >
+            <br>
+            {{mail.headers.from}}
+          </span>
+          <!-- ./ Name not defined -->
+
+        </td>
         <td class="subject" (click)="openMail(mail)">{{mail.subject}}</td>
         <td class="">{{mail.headers.date}}</td>
       </tr>

src/app/inbox/inbox-messages/inbox-messages.component.scss

@@ -5,3 +5,11 @@
   padding-top: 15px;
   border-radius: 5px;
 }
+
+
+.resolved-address {
+  font-style: italic;
+}
+.unresolved-address {
+  font-style: normal;
+}

src/app/inbox/inbox-messages/inbox-messages.component.spec.ts

@@ -7,13 +7,18 @@ import { HttpHelpersService } from 'src/app/services/helpers/http-helpers/http-h
 import { MailchainService } from 'src/app/services/mailchain/mailchain.service';
 import { ReadService } from 'src/app/services/mailchain/messages/read.service';
 import { of } from 'rxjs';
+import { NameserviceService } from 'src/app/services/mailchain/nameservice/nameservice.service';
 
 describe('InboxMessagesComponent', () => {
   let component: InboxMessagesComponent;
   let fixture: ComponentFixture<InboxMessagesComponent>;
   let mailchainService: MailchainService
   let readService: ReadService;
+  let nameserviceService: NameserviceService
 
+  const address1 = "0x0000000000000000000000000000000000000001"
+  const address2 = "0x0000000000000000000000000000000000000002"
+  const addresses = [address1,address2]
 
   class ReadServiceStub {
     markRead(msgId){
@@ -23,6 +28,26 @@ describe('InboxMessagesComponent', () => {
       return of(["ok"])
     }
   }
+  /**
+   * Resolves address1: myname.eth
+   * Throws 404 error for address2
+   */
+  class NameserviceServiceStub {
+    resolveAddress(protocol,network,value) {      
+      if (value == address1) {
+        return of(
+          {
+            "body": { name: "myname.eth" },
+            "ok": true
+          }
+        )
+      }
+      if (value == address2) {
+        return of({"status": 404})
+      }
+    }
+  }
+
   // id 00: unread & status ok;
   //        from: address 2
   //        to:   address 1
@@ -103,9 +128,7 @@ describe('InboxMessagesComponent', () => {
       "subject": "Message 05"
     }
   ]
-  const address1 = "0x0000000000000000000000000000000000000001"
-  const address2 = "0x0000000000000000000000000000000000000002"
-  const addresses = [address1,address2]
+
 
   beforeEach(async(() => {
     TestBed.configureTestingModule({
@@ -116,6 +139,7 @@ describe('InboxMessagesComponent', () => {
         HttpHelpersService,
         MailchainService,
         { provide: ReadService, useClass: ReadServiceStub },
+        { provide: NameserviceService, useClass: NameserviceServiceStub },
 
       ],
       imports: [
@@ -126,6 +150,7 @@ describe('InboxMessagesComponent', () => {
     .compileComponents();
     mailchainService = TestBed.get(MailchainService);
     readService = TestBed.get(ReadService);
+    nameserviceService = TestBed.get(NameserviceService);
 
   }));
 
@@ -165,6 +190,17 @@ describe('InboxMessagesComponent', () => {
     })
   });
 
+  describe('resolveSendersFromMessages', () => {
+    it('should include resolved names in messagesNameRecords', ()=>{
+      component.resolveSendersFromMessages(messages)
+      expect(component.messagesNameRecords[address1]).toEqual("myname.eth")
+    })
+    it('should not include unresolved names in messagesNameRecords', ()=>{
+      component.resolveSendersFromMessages(messages)
+      expect(component.messagesNameRecords[address2]).toEqual(undefined)
+    })
+  })
+
   describe('addMailToInboxMessages', () => {
 
     it('should add senderIdenticon to each message', ()=>{

src/app/inbox/inbox-messages/inbox-messages.component.ts

@@ -14,13 +14,16 @@ import { AddressPipe } from 'src/app/pipes/address-pipe/address-pipe.pipe';
 export class InboxMessagesComponent implements OnInit, OnChanges {
   @Input() messagesLoaded: boolean;
   @Input() currentAccount: string;
+  @Input() currentProtocol: string;
+  @Input() currentNetwork: string;
   @Input() inboxMessages: Array<any>;
 
   @Output() openMessage = new EventEmitter();
   @Output() inboxCounter = new EventEmitter<any>();
 
   public currentAccountInboxMessages: Array<any> = [];
   public searchText: string = '';
+  public messagesNameRecords = {}
 
   constructor(
     private mailchainService: MailchainService,
@@ -59,6 +62,18 @@ export class InboxMessagesComponent implements OnInit, OnChanges {
     });    
   }
 
+  /**
+   * resolveSendersFromMessages of messages by name according to the currentNetowkr and currentProtocol
+   * @param messagesArray the array of messages
+   */
+  resolveSendersFromMessages(messagesArray) {
+    this.messagesNameRecords = this.mailchainService.resolveSendersFromMessages(
+      this.currentProtocol,
+      this.currentNetwork,
+      messagesArray
+    )
+  }
+
   /**
    * addMailToInboxMessages adds a decrypted message object to the inboxMessages array with the correct attributes
    * @param decryptedMsg the decrypted message object
@@ -196,7 +211,10 @@ export class InboxMessagesComponent implements OnInit, OnChanges {
     this.currentAccountInboxMessages = []
     // Dedupe messages
     this.currentAccountInboxMessages = this.mailchainService.dedupeMessagesByIds(inboxMessagesFilteredByAddressSearch)
-
+
+    // fetch names for senders
+    this.resolveSendersFromMessages(this.currentAccountInboxMessages)
+
   }
 
   async ngOnChanges(event): Promise<void> {

src/app/inbox/inbox.component.html

@@ -71,6 +71,8 @@ <h1 class="page-title">Mailchain</h1>
     [messagesLoaded]="messagesLoaded"
     [currentAccount]="currentAccount"
     [inboxMessages]="inboxMessages"
+    [currentProtocol]="currentProtocol"
+    [currentNetwork]="currentNetwork"
 
     (openMessage)="onOpenMessage($event)"
     (inboxCounter)="onInboxCounter($event)"

src/app/pipes/address-pipe/address-pipe.pipe.spec.ts

@@ -1,5 +1,7 @@
 import { TestBed } from '@angular/core/testing';
 import { AddressPipe } from './address-pipe.pipe';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+import { HttpHelpersService } from 'src/app/services/helpers/http-helpers/http-helpers.service';
 
 let pipe: AddressPipe
 
@@ -41,9 +43,12 @@ describe('AddressPipe', () => {
   beforeEach(() => {
     TestBed.configureTestingModule({
       providers: [
-        AddressPipe
+        AddressPipe,
+        HttpHelpersService,
       ],
-      imports: []
+      imports: [
+        HttpClientTestingModule,
+      ]
     });
 
     pipe = TestBed.get(AddressPipe);

src/app/services/mailchain/mailchain.service.spec.ts

@@ -5,14 +5,40 @@ import { of } from 'rxjs';
 import { OutboundMail } from 'src/app/models/outbound-mail';
 import { Mail } from 'src/app/models/mail';
 import { HttpClientModule } from '@angular/common/http';
+import { NameserviceService } from './nameservice/nameservice.service';
 
 describe('MailchainService', () => {
   let mailchainService: MailchainService;
+  let nameserviceService: NameserviceService
 
+  const address1 = "0x0000000000000000000000000000000000000001"
+  const address2 = "0x0000000000000000000000000000000000000002"
+
+  /**
+   * Resolves address1: myname.eth
+   * Throws 404 error for address2
+   */
+  class NameserviceServiceStub {
+    resolveAddress(protocol,network,value) {      
+      if (value == address1) {
+        return of(
+          {
+            "body": { "name": "myname.eth" },
+            "ok": true
+          }
+        )
+      }
+      if (value == address2) {
+        return of({"status": 404})
+      }
+    }
+  }
+
   beforeEach(() => {
     TestBed.configureTestingModule({
       providers: [
         MailchainService,
+        { provide: NameserviceService, useClass: NameserviceServiceStub },
       ]
     });
 
@@ -142,6 +168,46 @@ describe('MailchainService', () => {
     });
   })
 
+  describe('dedupeMessagesBySender', () => {
+    let address1 = "<0x0000000000000000000000000000000000000001@ropsten.ethereum>"
+    let address2 = "<0x0000000000000000000000000000000000000002@ropsten.ethereum>"
+
+    let messages = [
+      { "headers": { "from": address1 } },
+      { "headers": { "from": address2 } },
+      { "headers": { "from": address1 } },
+      { "headers": { "from": address2 } },
+      { "headers": { "from": address1 } },
+    ]
+
+    it('should dedupe the senders of messages', ()=>{
+      let res = mailchainService.dedupeMessagesBySender(messages)
+      expect(res.length).toEqual(2)
+      expect(res).toEqual([
+        "0x0000000000000000000000000000000000000001",
+        "0x0000000000000000000000000000000000000002"
+      ])
+    })
+  })
+
+  describe('resolveSendersFromMessages', () => {
+    let address1 = "<0x0000000000000000000000000000000000000001@ropsten.ethereum>"
+    let address2 = "<0x0000000000000000000000000000000000000002@ropsten.ethereum>"
+
+    let messages = [
+      { "headers": { "from": address1 }, "status": "ok" },
+      { "headers": { "from": address2 }, "status": "ok" },
+    ]
+
+    it('should handle multiple messages', ()=>{
+      let res = mailchainService.resolveSendersFromMessages("ethereum","testnet",messages)
+
+      expect(res["0x0000000000000000000000000000000000000001"]).toEqual('myname.eth')
+      expect(res["0x0000000000000000000000000000000000000002"]).toEqual(undefined)
+
+    })
+  })
+
   describe('generateMail', () => {
     const mailObject = new Mail
     mailObject["to"] = "0xd5ab4ce3605cd590db609b6b5c8901fdb2ef7fe6"