Update retry handler used by Pro Client

android/.project

@@ -16,12 +16,12 @@
 	</natures>
 	<filteredResources>
 		<filter>
-			<id>1620924294143</id>
+			<id>1732230225439</id>
 			<name></name>
 			<type>30</type>
 			<matcher>
 				<id>org.eclipse.core.resources.regexFilterMatcher</id>
-				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
 			</matcher>
 		</filter>
 	</filteredResources>

desktop/app/app.go

@@ -87,7 +87,6 @@ type App struct {
 	ws            ws.UIChannel
 
 	cachedUserData sync.Map
-	plansCache     sync.Map
 
 	onUserData []func(current *protos.User, new *protos.User)
 
@@ -384,7 +383,7 @@ func (app *App) OnStatsChange(fn func(stats.Stats)) {
 func (app *App) afterStart(cl *flashlightClient.Client) {
 	ctx := context.Background()
 	go app.fetchOrCreateUser(ctx)
-	go app.GetPaymentMethods(ctx)
+	go app.proClient.DesktopPaymentMethods(ctx)
 	go app.fetchDeviceLinkingCode(ctx)
 
 	app.OnSettingChange(settings.SNSystemProxy, func(val interface{}) {
@@ -570,17 +569,18 @@ func (app *App) IsPro() bool {
 	return isPro
 }
 
-func (app *App) fetchOrCreateUser(ctx context.Context) (*protos.User, error) {
-	settings := app.Settings()
-	lang := settings.GetLanguage()
+func (app *App) fetchOrCreateUser(ctx context.Context) {
+	ss := app.Settings()
+	lang := ss.GetLanguage()
 	if lang == "" {
 		// set default language
-		settings.SetLanguage("en_us")
+		ss.SetLanguage("en_us")
 	}
-	if userID := settings.GetUserID(); userID == 0 {
-		return app.CreateUser(ctx)
+	if userID := ss.GetUserID(); userID == 0 {
+		ss.SetUserFirstVisit(true)
+		app.proClient.RetryCreateUser(ctx, app, 5*time.Minute)
 	} else {
-		return app.UserData(ctx)
+		app.proClient.UpdateUserData(ctx, app)
 	}
 }
 
@@ -600,145 +600,6 @@ func (app *App) fetchDeviceLinkingCode(ctx context.Context) (string, error) {
 	return resp.Code, nil
 }
 
-// CreateUser is used when Lantern is run for the first time and creates a new user with the pro server
-func (app *App) CreateUser(ctx context.Context) (*protos.User, error) {
-	log.Debug("New user, calling user create")
-	settings := app.Settings()
-	settings.SetUserFirstVisit(true)
-	resp, err := app.proClient.UserCreate(ctx)
-	if err != nil {
-		return nil, errors.New("Could not create new Pro user: %v", err)
-	}
-	user := resp.User
-	log.Debugf("DEBUG: User created: %v", user)
-	if resp.BaseResponse != nil && resp.BaseResponse.Error != "" {
-		return nil, errors.New("Could not create new Pro user: %v", err)
-	}
-	app.SetUserData(ctx, user.UserId, user)
-	settings.SetReferralCode(user.Referral)
-	settings.SetUserIDAndToken(user.UserId, user.Token)
-	go app.UserData(ctx)
-	return resp.User, nil
-}
-
-// Plans returns the plans available to a user
-func (app *App) Plans(ctx context.Context) ([]protos.Plan, error) {
-	if v, ok := app.plansCache.Load("plans"); ok {
-		resp := v.([]protos.Plan)
-		log.Debugf("Returning plans from cache %s", v)
-		return resp, nil
-	}
-	resp, err := app.FetchPaymentMethods(ctx)
-	if err != nil {
-		return nil, err
-	}
-	return resp.Plans, nil
-}
-
-// GetPaymentMethods returns the plans and payment from cache if available
-// if not then call FetchPaymentMethods
-func (app *App) GetPaymentMethods(ctx context.Context) ([]protos.PaymentMethod, error) {
-	if v, ok := app.plansCache.Load("paymentMethods"); ok {
-		resp := v.([]protos.PaymentMethod)
-		log.Debugf("Returning payment methods from cache %s", v)
-		return resp, nil
-	}
-	resp, err := app.FetchPaymentMethods(ctx)
-	if err != nil {
-		return nil, err
-	}
-	desktopProviders, ok := resp.Providers["desktop"]
-	if !ok {
-		return nil, errors.New("No desktop payment providers found")
-	}
-	return desktopProviders, nil
-}
-
-// FetchPaymentMethods returns the plans and payment plans available to a user
-func (app *App) FetchPaymentMethods(ctx context.Context) (*proclient.PaymentMethodsResponse, error) {
-	resp, err := app.proClient.PaymentMethodsV4(context.Background())
-	if err != nil {
-		return nil, errors.New("Could not get payment methods: %v", err)
-	}
-	desktopPaymentMethods, ok := resp.Providers["desktop"]
-	if !ok {
-		return nil, errors.New("No desktop payment providers found")
-	}
-	for i := range desktopPaymentMethods {
-		paymentMethod := &desktopPaymentMethods[i]
-		for j, provider := range paymentMethod.Providers {
-			if resp.Logo[provider.Name] != nil {
-				logos := resp.Logo[provider.Name].([]interface{})
-				for _, logo := range logos {
-					paymentMethod.Providers[j].LogoUrls = append(paymentMethod.Providers[j].LogoUrls, logo.(string))
-				}
-			}
-		}
-	}
-	//clear previous store cache
-	app.plansCache.Delete("plans")
-	app.plansCache.Delete("paymentMethods")
-	log.Debugf("DEBUG: Payment methods plans: %+v", resp.Plans)
-	log.Debugf("DEBUG: Payment methods providers: %+v", desktopPaymentMethods)
-	app.plansCache.Store("plans", resp.Plans)
-	app.plansCache.Store("paymentMethods", desktopPaymentMethods)
-	app.sendConfigOptions()
-	return resp, nil
-}
-
-// UserData looks up user data that is associated with the given UserConfig
-func (app *App) UserData(ctx context.Context) (*protos.User, error) {
-	log.Debug("Refreshing user data")
-	resp, err := app.proClient.UserData(context.Background())
-	if err != nil {
-		return nil, errors.New("error fetching user data: %v", err)
-	} else if resp.User == nil {
-		return nil, errors.New("error fetching user data")
-	}
-	userDetail := resp.User
-	settings := app.Settings()
-
-	setProUser := func(isPro bool) {
-		app.Settings().SetProUser(isPro)
-	}
-
-	currentDevice := app.Settings().GetDeviceID()
-
-	// Check if device id is connect to same device if not create new user
-	// this is for the case when user removed device from other device
-	deviceFound := false
-	if userDetail.Devices != nil {
-		for _, device := range userDetail.Devices {
-			if device.Id == currentDevice {
-				deviceFound = true
-				break
-			}
-		}
-	}
-
-	/// Check if user has installed app first time
-	firstTime := settings.GetUserFirstVisit()
-	log.Debugf("First time visit %v", firstTime)
-	if userDetail.UserLevel == "pro" && firstTime {
-		log.Debugf("User is pro and first time")
-		setProUser(true)
-	} else if userDetail.UserLevel == "pro" && !firstTime && deviceFound {
-		log.Debugf("User is pro and not first time")
-		setProUser(true)
-	} else {
-		log.Debugf("User is not pro")
-		setProUser(false)
-	}
-	settings.SetUserIDAndToken(userDetail.UserId, userDetail.Token)
-	settings.SetExpiration(userDetail.Expiration)
-	settings.SetReferralCode(resp.User.Referral)
-	log.Debugf("User caching successful: %+v", userDetail)
-	// Save data in userData cache
-	app.SetUserData(ctx, userDetail.UserId, userDetail)
-	app.SendUpdateUserDataToUI()
-	return resp.User, nil
-}
-
 func (app *App) devices() protos.Devices {
 	user, found := app.GetUserData(app.Settings().GetUserID())
 
@@ -810,3 +671,37 @@ func (app *App) ProClient() proclient.ProClient {
 	defer app.mu.RUnlock()
 	return app.proClient
 }
+
+// Client session methods
+func (app *App) FetchUserData() error {
+	go app.proClient.PaymentMethodsCache(context.Background())
+	return nil
+}
+
+func (app *App) GetDeviceID() (string, error) {
+	return app.Settings().GetDeviceID(), nil
+}
+
+func (app *App) GetUserFirstVisit() (bool, error) {
+	return app.Settings().GetUserFirstVisit(), nil
+}
+
+func (app *App) SetUserIDAndToken(id int64, token string) error {
+	app.Settings().SetUserIDAndToken(id, token)
+	return nil
+}
+
+func (app *App) SetProUser(pro bool) error {
+	app.Settings().SetProUser(pro)
+	return nil
+}
+
+func (app *App) SetReferralCode(referral string) error {
+	app.Settings().SetReferralCode(referral)
+	return nil
+}
+
+func (app *App) SetExpiration(exp int64) error {
+	app.Settings().SetExpiration(exp)
+	return nil
+}

desktop/app/config.go

@@ -84,8 +84,8 @@ func (app *App) sendConfigOptions() {
 		return authEnabled
 	}
 	ctx := context.Background()
-	plans, _ := app.Plans(ctx)
-	paymentMethods, _ := app.GetPaymentMethods(ctx)
+	plans, _ := app.proClient.Plans(ctx)
+	paymentMethods, _ := app.proClient.DesktopPaymentMethods(ctx)
 	devices, _ := json.Marshal(app.devices())
 	log.Debugf("DEBUG: Devices: %s", string(devices))
 	log.Debugf("Expiration date: %s", app.settings.GetExpirationDate())

desktop/auth.go

@@ -70,7 +70,7 @@ func signup(email *C.char, password *C.char) *C.char {
 	saveUserSalt(salt)
 	setting.SetEmailAddress(C.GoString(email))
 	a.SetUserLoggedIn(true)
-	a.FetchPaymentMethods(context.Background())
+	a.ProClient().PaymentMethodsCache(context.Background())
 	return C.CString("true")
 }
 
@@ -129,7 +129,7 @@ func logout() *C.char {
 
 	clearLocalUserData()
 	// Create new user
-	if _, err := a.CreateUser(ctx); err != nil {
+	if _, err := a.ProClient().UserCreate(ctx); err != nil {
 		return sendError(err)
 	}
 	return C.CString("true")
@@ -253,7 +253,7 @@ func deleteAccount(password *C.char) *C.char {
 		A:     A.Bytes(),
 	}
 	log.Debugf("Delete Account request email %v A %v", lowerCaseEmail, A.Bytes())
-	srpB, err := a.AuthClient().LoginPrepare(context.Background(), prepareRequestBody)
+	srpB, err := a.AuthClient().LoginPrepare(ctx, prepareRequestBody)
 	if err != nil {
 		return sendError(err)
 	}
@@ -299,7 +299,7 @@ func deleteAccount(password *C.char) *C.char {
 	if err != nil {
 		return sendError(err)
 	}
-	log.Debugf("Account Delted response %v", isAccountDeleted)
+	log.Debugf("Account deleted response %v", isAccountDeleted)
 
 	if !isAccountDeleted {
 		return sendError(log.Errorf("user_not_found error while deleting account %v", err))
@@ -310,8 +310,7 @@ func deleteAccount(password *C.char) *C.char {
 	// Set user id and token to nil
 	a.Settings().SetUserIDAndToken(0, "")
 	// Create new user
-	// Create new user
-	if _, err := a.CreateUser(ctx); err != nil {
+	if _, err := a.ProClient().UserCreate(ctx); err != nil {
 		return sendError(err)
 	}
 	return C.CString("true")

desktop/lib.go

@@ -129,19 +129,23 @@ func setProxyAll(value *C.char) {
 //
 //export hasPlanUpdatedOrBuy
 func hasPlanUpdatedOrBuy() *C.char {
+	ctx := context.Background()
+	proClient := a.ProClient()
+	go proClient.PollUserData(ctx, a, 10*time.Minute, proClient)
 	//Get the cached user data
 	log.Debugf("DEBUG: Checking if user has updated plan or bought new plan")
 	cacheUserData, isOldFound := cachedUserData()
 	//Get latest user data
-	resp, err := a.ProClient().UserData(context.Background())
+	resp, err := a.ProClient().UserData(ctx)
 	if err != nil {
 		return sendError(err)
 	}
 	if isOldFound {
-		if cacheUserData.Expiration < resp.User.Expiration {
+		user := resp.User
+		if cacheUserData.Expiration < user.Expiration {
 			// New data has a later expiration
 			// if foud then update the cache
-			a.Settings().SetExpiration(resp.User.Expiration)
+			a.Settings().SetExpiration(user.Expiration)
 			return C.CString(string("true"))
 		}
 	}
@@ -249,8 +253,6 @@ func testProviderRequest(email *C.char, paymentProvider *C.char, plan *C.char) *
 	if err != nil {
 		return sendError(err)
 	}
-	//a.SetProUser(true)
-	go a.UserData(ctx)
 	return C.CString("true")
 }
 
@@ -364,7 +366,8 @@ func deviceLinkingCode() *C.char {
 //export paymentRedirect
 func paymentRedirect(planID, currency, provider, email, deviceName *C.char) *C.char {
 	country := a.Settings().GetCountry()
-	resp, err := a.ProClient().PaymentRedirect(context.Background(), &protos.PaymentRedirectRequest{
+	ctx := context.Background()
+	resp, err := a.ProClient().PaymentRedirect(ctx, &protos.PaymentRedirectRequest{
 		Plan:        C.GoString(planID),
 		Provider:    C.GoString(provider),
 		Currency:    strings.ToUpper(C.GoString(currency)),
@@ -375,6 +378,7 @@ func paymentRedirect(planID, currency, provider, email, deviceName *C.char) *C.c
 	if err != nil {
 		return sendError(err)
 	}
+
 	return sendJson(resp)
 }
 

desktop/settings/settings.go

@@ -508,6 +508,11 @@ func (s *Settings) GetLanguage() string {
 	return s.getString(SNLanguage)
 }
 
+// Locale returns the user language
+func (s *Settings) Locale() string {
+	return s.getString(SNLanguage)
+}
+
 // SetReferralCode sets the user referral code
 func (s *Settings) SetReferralCode(referralCode string) {
 	s.setVal(SNReferralCode, referralCode)
@@ -615,6 +620,11 @@ func (s *Settings) GetToken() string {
 	return s.getString(SNUserToken)
 }
 
+// GetToken returns the user token
+func (s *Settings) FetchUserData() error {
+	return nil
+}
+
 // GetMigratedDeviceIDForUserID returns the user ID (if any) for which the current device's ID has been migrated from the old style to the new style
 func (s *Settings) GetMigratedDeviceIDForUserID() int64 {
 	return s.getInt64(SNMigratedDeviceIDForUserID)