Mobile app

backend/app-logic/auth.ts

@@ -117,7 +117,12 @@ export default class Auth {
     if (shouldValidate) {
       var rs = await UserValidate.checkNewUserValid(user)
       if (rs instanceof Error) {
-        throw rs
+        //@ts-ignore
+        const errors = rs.details.map(ve => {
+          const key = ve.path[0]
+          return `${key}::${ve.message}`
+        })
+        throw errors.join(" ;")
       }
       if (!this.models.config.AUTO_CONFIRM_EMAIL) {
         user.disabled = disabledReason.EMAIL_NOT_VERIFIED

backend/app-logic/blockchain.ts

@@ -0,0 +1,10 @@
+import { IModels } from "./index"
+//import { Transaction } from "../models/notifications/types"
+
+export default class Blockchain {
+  constructor(private models: IModels) {}
+
+  public async logTransaction(user_id: number): Promise<string> {
+    return [notifications, unreadCount]
+  }
+}

backend/app-logic/leads.ts

@@ -4,6 +4,24 @@ import { IModels } from "./index"
 import { Notification } from "../models/notifications/types"
 
 import * as _ from "lodash"
+import config from "./config"
+var request = require("request-promise")
+
+const logTransaction = async ({ fiat_amount, exchange_rate, leads_count }) => {
+  const res = await request({
+    uri: "http://blockchain.leadcoin.network/exchange",
+    method: "POST",
+    json: true,
+    body: {
+      fiat_amount,
+      exchange_rate,
+      leads_count,
+    },
+  })
+  return res
+  //{ txid: '0x9d6cd285dd8ac7bde247da8943ca2b536f58d7cac79deac975ba48766901eb68',
+  //  link: 'http://ropsten.etherscan.io/tx/0x9d6cd285dd8ac7bde247da8943ca2b536f58d7cac79deac975ba48766901eb68' }
+}
 
 export interface getLeadsOptions {
   sort_by?: [string, "ASC" | "DESC"]
@@ -16,11 +34,11 @@ const contains_contact = lead => {
   return lead.telephone || lead.name || lead.email || lead["Contact Person"]
 }
 
-const validate_lead = (lead) => {
+const validate_lead = lead => {
   const errors = []
-  if (!lead.lead_price) errors.push("lead_price::Lead price is required")
+  if (!lead.lead_price) errors.push("lead_price::Lead price is required.")
   if (!contains_contact(lead)) {
-    errors.push("phone::At least one contact info is required")
+    errors.push("phone::At least one contact info is required.")
     errors.push("name::")
     errors.push("email::")
   }
@@ -33,6 +51,18 @@ export default class Leads {
   constructor(private models: IModels) {}
   public UploadCSV() {}
 
+  public async getOwnedLeads() {
+    return await this.models.leads.getOwnedLeads()
+  }
+
+  public async getSingleLead(id) {
+    return await this.models.leads.getSingleLead(id)
+  }
+
+  public async getOwners() {
+    return await this.models.leads.getOwners()
+  }
+
   public async moveMyLeadsToSellLeads(leads: number[]) {
     return await this.models.leads.moveMyToSell(leads)
   }
@@ -49,7 +79,7 @@ export default class Leads {
     }
     buyer.balance = buyer.balance | 0
     if (buyer.balance < deal_price) {
-      throw new Error("balance::Amount insufficient")
+      throw new Error("balance::Amount insufficient.")
     }
     const result = await this.models.leads.buy(leads, new_owner)
     const groupedByOwner = _.groupBy(result, "bought_from")
@@ -61,15 +91,29 @@ export default class Leads {
       overall_cost += transaction_amount
       this.models.users.increaseBalance(seller, transaction_amount)
       this.models.notifications.createNotification({
-        msg: `${
+        msg: `Someone bought ${
           group.length
-        } of your leads were bought for a total of ${overall_cost}$`,
+        } of your leads for a total of ${overall_cost}$.`,
         userId: seller,
         unread: true,
       })
     }
     this.models.users.decreaseBalance(new_owner, overall_cost)
-    return result
+    const txDetails = await logTransaction({
+      leads_count: result.length.toString(),
+      fiat_amount: (overall_cost * 100).toString(),
+      exchange_rate: "1999000000000000000",
+    })
+    /*
+    I'll just comment this part out instead of deleting it, maybe they'll want it back someday (@Leekao)
+
+    this.models.notifications.createNotification({
+      msg: "Your transaction was logged to " + txDetails.link,
+      userId: new_owner,
+      unread: true,
+    })
+    */
+    return txDetails
   }
 
   public async removeLead(lead_id: number) {
@@ -94,6 +138,20 @@ export default class Leads {
     throw new Error(problems.join(" ;"))
   }
 
+  public async EditLead(lead: Lead) {
+    const problems = validate_lead(lead)
+    if (problems.length > 0) throw new Error(problems.join(" ;"))
+    lead = await this.sanitizeLead(lead)
+    const current_lead = await this.models.leads.getSingleLead(lead.id)
+    console.log({ current_lead, lead })
+    switch (true) {
+      case current_lead.ownerId != lead.ownerId:
+      case !current_lead.active:
+        throw new Error("general::lead mutated.")
+    }
+    return await this.models.leads.EditLead(lead)
+  }
+
   public async getMockLeads(user_id: number) {
     return await this.models.leads.getMockLeads(user_id)
   }
@@ -107,11 +165,16 @@ export default class Leads {
   }
 
   public async getMyLeads(user_id: number, options: LeadQueryOptions) {
-    return await this.models.leads.getMyLeads(user_id, options)
+    const leads = await this.models.leads.getMyLeads(user_id, options)
+    return leads
   }
 
   public async getBoughtLeads(user_id: number, options: LeadQueryOptions) {
-    return await this.models.leads.getBoughtLeads(user_id, options)
+    const leads = await this.models.leads.getBoughtLeads(user_id, options)
+    leads.list = leads.list.map(l => {
+      return Object.assign(l, { lead_price: null })
+    })
+    return leads
   }
 
   public async getAllLeads(options: LeadQueryOptions) {

backend/models/base-db-model/base-db-model.ts

@@ -86,6 +86,28 @@ export default abstract class BaseDBModel<INew, IExisting, ICondition> {
   }
 
   leadsQueries = {
+    getOwnedLeads: async () => {
+      let sql = `
+      SELECT count(id) as cid
+      FROM leadcoin.leads
+      WHERE
+          doc->>"$.ownerId" > 0
+      AND doc->>"$.bought_from" > 0 
+      ;`
+      let rows = await this.sql.query(sql)
+      return rows.map(r => r.cid)
+    },
+    getOwners: async () => {
+      let sql = `
+      SELECT DISTINCT doc->>"$.ownerId" as owner
+      FROM leadcoin.leads
+      WHERE
+          doc->>"$.ownerId" > 0
+      AND doc->>"$.bought_from" > 0 
+      ;`
+      let rows = await this.sql.query(sql)
+      return rows.map(r => r.owner)
+    },
     getMockLeads: async user_id => {
       let sql = `
       SELECT id
@@ -121,11 +143,12 @@ export default abstract class BaseDBModel<INew, IExisting, ICondition> {
     getBoughtLeads: async (user_id: number, options: any) => {
       const { limit, filters, sort } = options
       let where_additions = []
+
       if (filters) {
         where_additions = filters
           .map(f => {
             const escaped = mysql.escape(f.val)
-            return `${this.fieldName} ->> "$.${f.field}" ${
+            return `${this.fieldName}->>${mysql.escape("$." + f.field)} ${
               f.op
             } "%${escaped.slice(1, -1)}%"`
           })
@@ -157,38 +180,56 @@ export default abstract class BaseDBModel<INew, IExisting, ICondition> {
     },
 
     buyLeadsGetAll: async (options: any) => {
-      const { limit, filters, sort } = options
-      let where_additions = []
-      if (filters) {
-        where_additions = filters
+      const { limit, filters, sort, user_id } = options
+      let where_additions = ""
+      let search_additions = []
+      if (filters.search) {
+        search_additions = filters.search
           .map(f => {
             const escaped = mysql.escape(f.val)
-            return `${this.fieldName} ->> "$.${f.field}" ${
+            if (f.field.includes(" ")) f.field = '"' + f.field + '"'
+            if (f.field.includes("/")) f.field = '"' + f.field + '"'
+            return `${this.fieldName}->>${mysql.escape("$." + f.field)} ${
               f.op
             } "%${escaped.slice(1, -1)}%"`
           })
-          .join(" OR ")
+          .join(`\nOR `)
       }
+      if (filters.industry)
+        where_additions = `${this.fieldName}->>'$.Industry' = '${
+          filters.industry
+        }'`
+      if (filters.category)
+        where_additions +=
+          (where_additions ? `\nAND ` : "") +
+          `${this.fieldName}->>'$.Category' = '${filters.category}'`
+      if (search_additions.length > 0)
+        where_additions +=
+          (where_additions ? `\nAND ` : "") + "(" + search_additions + ")"
       let limit_addition = ""
       let countHeader = "SELECT COUNT(*) as count "
       let realHeader = "SELECT *"
-      let query = `
-        FROM leads
-        WHERE doc->>"$.active" = "true"
-        AND doc->>"$.forSale" = "true" 
-      `
-      if (where_additions.length > 0) query += `AND ${where_additions}`
+      let query = `\nFROM leads\nWHERE doc->>'$.active' = 'true'\nAND doc->>'$.forSale' = 'true'`
+      if (user_id) query += `\nAND doc->>'$.ownerId' <> ${user_id} `
+      if (where_additions) query += `\nAND ${where_additions}`
       if (sort) {
-        query += ` ORDER BY ${this.fieldName} ->> ${mysql.escape(
+        query += `\nORDER BY ${this.fieldName}->>${mysql.escape(
           "$." + sort.sortBy,
         )} ${sort.sortOrder}`
       }
       if (limit) {
-        limit_addition += ` LIMIT ${limit.start},${limit.offset} `
+        limit_addition += `\nLIMIT ${limit.start},${limit.offset} `
       }
       let count = await this.sql.query(countHeader + query)
       let rows = await this.sql.query(realHeader + query + limit_addition)
       rows = rows.map(row => this.convertRowToObject(row)) // remove RowDataPacket class
+      rows = rows.map(row => {
+        return Object.assign(row, {
+          "Contact Person": "**********",
+          Email: "*********@gmail.com",
+          Telephone: row["Telephone"].substring(0, 6) + "******",
+        })
+      }) // remove contact information
       return { list: rows, total: count[0].count }
     },
 
@@ -236,7 +277,7 @@ export default abstract class BaseDBModel<INew, IExisting, ICondition> {
         where_additions = filters
           .map(f => {
             const escaped = mysql.escape(f.val)
-            return `${this.fieldName} ->> "$.${f.field}" ${
+            return `${this.fieldName} ->> ${mysql.escape("$." + f.field)} ${
               f.op
             } "%${escaped.slice(1, -1)}%"`
           })
@@ -374,7 +415,10 @@ export default abstract class BaseDBModel<INew, IExisting, ICondition> {
     this.log("update " + this.tableName + " start", record)
     var str = ""
     var values = Object.keys(record).forEach(key => {
-      str += `, ${mysql.escape("$." + key)} , ${mysql.escape(record[key])}`
+      const value = record[key]
+      if (key.includes(" ")) key = '"' + key + '"'
+      if (key.includes("/")) key = '"' + key + '"'
+      str += `, ${mysql.escape("$." + key)} , ${mysql.escape(value)}`
     })
 
     var query = `UPDATE ${this.tableName} SET ${this.fieldName}=JSON_SET(${

backend/models/csv_reader/index.ts

@@ -26,7 +26,7 @@ export function parseMappedFile(
 ) {
   let records = papaparse.parse(fileContents, parseConfig).data
   const leads = records.map(line => {
-    const lead: NewRealEstateLead = {
+    const lead = {
       lead_price,
       ownerId: user_id,
       date: new Date().valueOf(),

backend/models/email-creator/email-creator.ts

@@ -75,13 +75,6 @@ class EmailCreator {
         "Temporary password: " +
         password +
         "<br><br>" +
-        "This password is temporary, so please " +
-        '<a href="' +
-        this.backend +
-        "/login" +
-        '">' +
-        "login" +
-        "</a> and immediately change it.<br><br> " +
         "Best Regards,<br><br>" +
         "The LeadCoin Team",
     }

backend/models/leads/leads.ts

@@ -18,6 +18,10 @@ export default class Leads extends baseDBModel<
     return await this.insert(lead)
   }
 
+  public async EditLead(lead: Lead) {
+    return await this.update(lead.id, lead)
+  }
+
   public async insertLead(new_lead: Lead) {
     return this.insert(new_lead)
   }
@@ -34,6 +38,13 @@ export default class Leads extends baseDBModel<
     return this.find({ condition, sort, limit })
   }
 
+  public async getOwnedLeads() {
+    return await this.leadsQueries.getOwnedLeads()
+  }
+  public async getOwners() {
+    return await this.leadsQueries.getOwners()
+  }
+
   public async getSoldLeads(user_id: number, options: LeadQueryOptions) {
     return await this.leadsQueries.getSoldLeads(user_id, options)
   }
@@ -54,6 +65,10 @@ export default class Leads extends baseDBModel<
     return await this.leadsQueries.getMyLeads(user_id, options)
   }
 
+  public async getSingleLead(lead_id: number) {
+    return await this.getById(lead_id)
+  }
+
   public async getDealPrice(lead_ids: number[]) {
     return await this.leadsQueries.getDealPrice(lead_ids)
   }