1
00:00:02,100 --> 00:00:03,360
Więc wiele osiągnęliśmy,

2
00:00:03,390 --> 00:00:05,460
jesteśmy w stanie zapisywać dane, pobierać dane,

3
00:00:05,460 --> 00:00:08,190
używać naszego tokena do określania zakresu danych lub określania zakresu

4
00:00:08,190 --> 00:00:10,950
produktów i zamówień do naszego aktualnie zalogowanego użytkownika, jesteśmy w

5
00:00:10,950 --> 00:00:12,610
stanie zalogować się i tak dalej,

6
00:00:12,620 --> 00:00:14,280
i to wszystko jest miłe.

7
00:00:14,280 --> 00:00:20,130
Jedną z rzeczy, których obecnie nie robimy, jest to, że nie kontynuujemy naszych

8
00:00:20,130 --> 00:00:23,970
sesji, że tak powiem. Jeśli przeładuję, zawsze muszę się

9
00:00:24,030 --> 00:00:25,230
ponownie zalogować i

10
00:00:25,230 --> 00:00:31,170
nie jest to tak naprawdę to, co chciałbym, byłoby miło, gdybyśmy mogli automatycznie zalogować się, jeśli mamy

11
00:00:31,170 --> 00:00:38,310
prawidłowy token, i do tego musimy zrobić dwie rzeczy - musimy przechowywać token gdzieś na urządzeniu, a nie w Redux,

12
00:00:38,310 --> 00:00:43,110
ponieważ Redux jest w pamięci i zostanie to utracone przy każdym uruchomieniu aplikacji.

13
00:00:43,110 --> 00:00:45,920
Musimy więc powiedzieć, że musi być gdzieś

14
00:00:45,930 --> 00:00:53,480
na dysku twardym urządzenia, a ponadto musimy sprawdzać tę pamięć za każdym razem, gdy uruchamia się nasza aplikacja, i automatycznie

15
00:00:53,480 --> 00:00:58,080
ustawiać token w Redux i przekierowywać użytkownika, jeśli znajdziemy tam prawidłowy token.

16
00:00:59,160 --> 00:01:05,590
Teraz zacznijmy od przechowywania, ponieważ jest to logiczny pierwszy krok. Aby przechowywać, musimy zaimportować

17
00:01:05,590 --> 00:01:10,090
coś tutaj, a nie w kreatorze akcji

18
00:01:10,090 --> 00:01:20,810
produktów, ale tak naprawdę tutaj, w kreatorze akcji auth, tam trzeba zaimportować pamięć asynchroniczną z React Native.

19
00:01:21,930 --> 00:01:23,280
Po zaimportowaniu

20
00:01:23,460 --> 00:01:32,130
możemy użyć tego do zapisania danych na urządzeniu, pamięć asynchroniczna to React Native API, który ostatecznie korzysta z pamięci kluczowych wartości

21
00:01:32,130 --> 00:01:38,370
na urządzeniu, która jest dostępna zarówno na iOS, jak i na Androidzie, gdzie możemy przechowywać

22
00:01:38,370 --> 00:01:45,150
dane, które będą się utrzymywać między uruchomieniami aplikacji, dzięki którym możemy zapisywać dane, które nie zostaną utracone

23
00:01:45,150 --> 00:01:47,460
podczas uruchamiania lub ponownego uruchamiania aplikacji.

24
00:01:47,460 --> 00:01:52,910
Dodam więc nową funkcję, zapiszę dane w pamięci lub coś w tym stylu i

25
00:01:53,040 --> 00:02:00,100
tam spodziewam się, że otrzymam mój token i identyfikator użytkownika, dwa fragmenty danych, którymi jestem zainteresowany, i możemy

26
00:02:00,140 --> 00:02:08,970
teraz użyć pamięci asynchronicznej do tego czasu ustaw element, w jaki sposób zapisujesz dane, a ten element, który ustawiasz, musi być ciągiem,

27
00:02:08,970 --> 00:02:11,560
ale przede wszystkim musisz zdefiniować klucz,

28
00:02:11,580 --> 00:02:14,840
a ja nadam mu nazwę użytkownika, ale to

29
00:02:14,850 --> 00:02:19,260
zależy od ciebie, później będziesz potrzebować tego klucza aby odzyskać dane,

30
00:02:19,330 --> 00:02:21,170
a drugą wartością jest

31
00:02:21,180 --> 00:02:26,310
teraz ciąg, więc ciąg, który chcesz tam zapisać i musisz zasadniczo zapisać ciąg.

32
00:02:26,440 --> 00:02:27,340
Teraz

33
00:02:27,340 --> 00:02:33,990
to żaden problem, możemy użyć JSON. stringify, aby przekonwertować obiekt JavaScript na ciąg znaków, a

34
00:02:33,990 --> 00:02:40,200
obiekt, który chcę przekonwertować, to obiekt, który przechowuje mój token, który otrzymuję jako argument i zawiera identyfikator użytkownika,

35
00:02:40,200 --> 00:02:41,740
który otrzymuję jako argument.

36
00:02:41,790 --> 00:02:48,980
Na koniec zapisujemy ten obiekt jako ciąg na urządzeniu.

37
00:02:48,990 --> 00:02:54,590
Teraz musimy po prostu wywołać zapisywanie danych do pamięci za każdym razem, gdy logujemy się lub rejestrujemy, więc tutaj może po

38
00:02:54,590 --> 00:03:01,080
wysłaniu loginu możemy wywołać zapisywanie danych do pamięci i przekazywać resData. idToken

39
00:03:01,140 --> 00:03:08,100
i resData. localId, więc te same rzeczy, których używamy w Redux

40
00:03:08,100 --> 00:03:11,610
i na pewno chcemy ich tam użyć, ponieważ Redux jest ważny

41
00:03:11,850 --> 00:03:18,090
dla działającej aplikacji, ale zapisuję go również na urządzeniu, gdy chcemy go załadować, gdy aplikacja uruchomi się ponownie.

42
00:03:18,140 --> 00:03:22,810
Teraz jednak to samo nie załatwi sprawy i oczywiście musimy to zrobić

43
00:03:22,820 --> 00:03:28,340
również podczas rejestracji, ale to samo nie załatwi sprawy, potrzebujemy tutaj dodatkowej informacji, zanim przejdziemy dalej.

44
00:03:28,430 --> 00:03:35,780
Czy wiesz który Musimy wiedzieć, jak długo token jest ważny, ponieważ nie

45
00:03:36,230 --> 00:03:42,920
możesz zapominać, że w końcu wygaśnie, dlatego do logowania i rejestracji dostaniesz to, co wygasa Kluczem

46
00:03:43,310 --> 00:03:50,510
w odpowiedzi, który mówi w sekundach, ile czasu zajmuje do tokenów jest nieprawidłowy i Firebase nie będzie go

47
00:03:50,510 --> 00:03:51,510
już akceptować.

48
00:03:51,650 --> 00:03:57,590
Musimy również przechowywać te informacje, ponieważ jeśli później wrócimy, jeśli ponownie uruchomimy aplikację po trzech godzinach,

49
00:03:57,590 --> 00:04:01,390
nasz token jest prawdopodobnie nieprawidłowy, więc musimy wiedzieć, kiedy token

50
00:04:01,460 --> 00:04:04,370
zostanie unieważniony, abyśmy mogli to sprawdzić, kiedy

51
00:04:04,370 --> 00:04:09,800
aplikacja uruchomi się ponownie, gdy sprawdzimy, czy mamy token, wiemy, czy ten token, który możemy

52
00:04:09,800 --> 00:04:16,460
znaleźć, jest nadal aktualny, czy też już jest nieważny i tak czy inaczej potrzebujemy nowego tokena, w którym

53
00:04:16,460 --> 00:04:20,120
to przypadku nie powinniśmy automatycznie logować się do użytkownika.

54
00:04:20,480 --> 00:04:23,360
Chcę więc zapisać datę

55
00:04:23,360 --> 00:04:31,180
ważności i utworzę tutaj datę ważności jako stałą, nowy obiekt daty, który ostatecznie powinien

56
00:04:31,180 --> 00:04:35,020
przyjąć aktualną datę i dodać czas wygaśnięcia.

57
00:04:37,810 --> 00:04:45,790
Teraz nowa data pobiera obiekt daty, ale wraz z czasem otrzymujemy bieżący znacznik czasu w milisekundach od początku

58
00:04:45,790 --> 00:04:49,590
czasu, że tak powiem, czyli tutaj w JavaScript w

59
00:04:49,780 --> 00:04:51,200
1970 roku.

60
00:04:51,570 --> 00:04:57,630
To jest ilość w milisekundach i do tego możemy dodać resData. termin upływa.

61
00:04:58,210 --> 00:05:01,720
Jest to liczba sekund, więc musimy przekonwertować to

62
00:05:01,720 --> 00:05:06,910
na milisekundy, a także ciąg znaków, więc musimy przekonwertować to na liczbę.

63
00:05:06,910 --> 00:05:16,490
Więc tutaj dodam tutaj plus lub po prostu przeanalizuję alternatywnie, aby przekonwertować to na liczbę całkowitą, a następnie pomnożę to przez

64
00:05:16,490 --> 00:05:23,550
1000, aby przekonwertować to z sekund na milisekundy, ponieważ zysk czasu daje nam również milisekundy.

65
00:05:23,570 --> 00:05:29,690
To, co mi to daje, to nowy znacznik czasu w przyszłości, czyli czas

66
00:05:29,690 --> 00:05:35,990
bieżący plus czas wygaśnięcia, i zawijam to w inny obiekt daty, aby przekonwertować go

67
00:05:36,110 --> 00:05:44,520
z ogromnej liczby milisekund na konkretny obiekt daty. Ta data wygaśnięcia jest teraz również tym, co musimy przekazać, aby

68
00:05:44,530 --> 00:05:48,880
zapisać dane w pamięci, więc tutaj spodziewam się również daty wygaśnięcia

69
00:05:48,880 --> 00:05:51,070
i musimy to załączyć tutaj.

70
00:05:51,400 --> 00:05:55,810
Więc tutaj mogę nazwać tę datę ważności, żeby

71
00:05:55,840 --> 00:06:05,830
ją pomieszać, to moja data ważności i tam chcę wywołać tę miłą, małą metodę toISOString, którą możemy wywoływać w

72
00:06:05,830 --> 00:06:11,500
obiektach daty, ponieważ to przekształci ją w ciąg znaków w standardowym

73
00:06:11,500 --> 00:06:14,240
formacie, który Chcę zapisać

74
00:06:14,400 --> 00:06:18,150
Teraz to właśnie chcę zrobić, aby się zarejestrować, więc

75
00:06:18,150 --> 00:06:20,190
można to tam skopiować i

76
00:06:20,520 --> 00:06:22,120
to też chcę

77
00:06:22,170 --> 00:06:26,220
tam zrobić, utworzyć datę wygaśnięcia i zapisać ją w pamięci.

78
00:06:26,220 --> 00:06:29,220
Teraz zapisujemy to w pamięci, co jest miłe,

79
00:06:29,670 --> 00:06:35,670
ale teraz musimy to sprawdzić również podczas logowania. Fajnym sposobem na to jest utworzenie nowego

80
00:06:35,670 --> 00:06:41,040
ekranu, a ja utworzę go poza moimi istniejącymi folderami w folderze ekranów, ale

81
00:06:41,040 --> 00:06:47,570
ani w sklepie, ani w użytkowniku. Nazwie ten ekran startowy i możesz go nazwać jakkolwiek ty chcieć.

82
00:06:47,610 --> 00:06:54,240
Chodzi o to, że pokazuję ten ekran podczas uruchamiania mojej aplikacji i zastanawiam się, czy użytkownik jest uwierzytelniony, czy nie, i

83
00:06:54,240 --> 00:06:55,380
to będzie super

84
00:06:55,380 --> 00:06:56,770
szybkie, są szanse, że

85
00:06:56,790 --> 00:07:02,350
nawet nie zobaczymy tego ekranu, gdy aplikacja się uruchomi. Teraz tutaj tworzymy zwykły komponent

86
00:07:02,370 --> 00:07:06,670
React poprzez importowanie reakcji z reakcji i tam importuję

87
00:07:06,910 --> 00:07:11,120
rzeczy z React Native, a konkretnie potrzebuję widoku, wskaźnika

88
00:07:11,130 --> 00:07:17,310
aktywności pokazującego ładowanie tarczy podczas uruchamiania aplikacji, a także arkusz stylów, a także

89
00:07:17,310 --> 00:07:23,280
pamięć asynchroniczna, ponieważ tutaj chcę również uzyskać dostęp do pamięci asynchronicznej, aby

90
00:07:23,280 --> 00:07:26,450
dowiedzieć się, czy mamy prawidłowy token.

91
00:07:26,460 --> 00:07:33,660
Więc tutaj mam komponent ekranu startowego, który jest zwykłym komponentem React, oraz obiekt

92
00:07:33,780 --> 00:07:44,570
arkusza stylów tutaj z Arkuszem stylów. utwórz i ostatecznie możemy wyeksportować ten ekran startowy w ten sposób. Teraz w komponencie przedstawię

93
00:07:44,580 --> 00:07:56,450
tutaj wskaźnik aktywności o wielkości dużej i kolorze kolorów. podstawowy i do tego trzeba oczywiście zaimportować

94
00:07:56,450 --> 00:08:05,100
stałe kolory, a także przypisać trochę stylu do widoku, a ja

95
00:08:05,100 --> 00:08:13,520
po prostu wezmę style. tutaj ekran, który możemy teraz dodać do

96
00:08:13,520 --> 00:08:16,530
arkusza stylów i który

97
00:08:16,690 --> 00:08:23,690
powinien być bardzo prosty, uelastycznij, uzasadnij centrum treści i wyrównaj centrum przedmiotów dla

98
00:08:23,720 --> 00:08:29,870
niektórych treści wyśrodkowanych pionowo i poziomo. Teraz oczywiście ważne rzeczy dzieją się nad

99
00:08:29,870 --> 00:08:33,520
kodem jsx, tutaj musimy teraz sprawdzić pamięć asynchroniczną pod

100
00:08:33,620 --> 00:08:39,820
kątem prawidłowego tokena i mogę to zrobić za pomocą efektu use, który pozwala mi uruchomić

101
00:08:39,820 --> 00:08:42,230
logikę tutaj, gdy ten komponent

102
00:08:42,250 --> 00:08:51,190
zamontowany i rzeczywiście tutaj nie będę potrzebował żadnych zależności, ponieważ tutaj efekt użycia, chcę teraz dodać nową funkcję, którą nazwiemy, spróbuj

103
00:08:51,190 --> 00:08:58,060
zarejestrować się lub spróbuj zalogować się bardziej pasuje i używam osobnej funkcji, ponieważ tutaj chcę użyć

104
00:08:58,090 --> 00:09:04,390
asynchronizacji czekaj, co mogę zrobić, tworząc wewnętrzną funkcję, którą teraz mogę tutaj wywołać, spróbuj się

105
00:09:04,390 --> 00:09:05,310
zalogować,

106
00:09:05,410 --> 00:09:10,840
ponieważ ponownie, asynchronizacja tutaj tej funkcji, którą przekazujesz, aby użyć efektu, naprawdę nie

107
00:09:10,840 --> 00:09:14,020
byłaby dozwolona, a tutaj przy próbie zalogowania

108
00:09:14,170 --> 00:09:21,460
cel teraz sprawdza poprawność tokena w pamięci asynchronicznej. Dostaję tutaj moje dane użytkownika, uzyskując dostęp do

109
00:09:21,520 --> 00:09:23,030
AsyncStorage.

110
00:09:23,240 --> 00:09:28,750
getItem, a następnie użyj klucza użytego do przechowywania.

111
00:09:28,960 --> 00:09:35,950
Tak więc w moim przypadku są to dane użytkownika, ale musisz użyć dowolnego klucza użytego w uwierzytelnieniu. plik js w folderze akcji

112
00:09:35,950 --> 00:09:43,160
do przechowywania danych w pamięci asynchronicznej. Odzyskuję to i teraz ważne jest, aby wiedzieć, że

113
00:09:43,160 --> 00:09:49,970
element get, podobnie jak wszystkie metody magazynowania asynchronicznego, w rzeczywistości jest asynchroniczny, co oznacza, że tak jak

114
00:09:50,030 --> 00:09:55,520
sugeruje nazwa, co oznacza, że dostaniesz tutaj obietnicę, więc możemy poczekać na to i

115
00:09:55,520 --> 00:09:58,560
zwróci nam to nasze dane użytkownika.

116
00:09:58,570 --> 00:10:05,200
Teraz są to dane jako ciąg, aby przekonwertować je na kawałek danych, z którymi

117
00:10:05,230 --> 00:10:14,410
możemy pracować, będę mieć moje przekształcone dane w JSON. parsuje dane użytkownika, a to analizuje ciąg znaków w

118
00:10:14,410 --> 00:10:24,220
formacie JSON i konwertuje go na obiekt lub tablicę JavaScript. Teraz jeszcze zanim spróbuję, sprawdzę, czy dane użytkownika nie są zgodne z prawdą, więc

119
00:10:24,220 --> 00:10:24,850
jeśli

120
00:10:24,850 --> 00:10:31,030
nie są ustawione, czy nie możemy znaleźć żadnych danych dla tego klucza, ponieważ wiem, że na pewno nie

121
00:10:31,030 --> 00:10:31,720
jesteśmy zalogowani.

122
00:10:31,780 --> 00:10:36,370
Więc tutaj chcę wrócić i nie kontynuować i zrobić jedną

123
00:10:36,370 --> 00:10:43,810
ważną rzecz, użyję nawigacji rekwizytów i przejdę do ekranu uwierzytelniania, ponieważ ten ekran startowy musi zostać

124
00:10:43,810 --> 00:10:44,770
dodany

125
00:10:45,190 --> 00:10:52,960
do nawigatora, więc tutaj możemy go zaimportować, zaimportować ekran startowy oczywiście z folderu ekrany, ekran startowy i

126
00:10:54,070 --> 00:10:57,590
dodajemy go do głównego w nawigatorze tutaj,

127
00:10:57,760 --> 00:11:07,190
więc tam, gdzie mamy również autoryzację i zakupy, a tam na samej górze, dodaję start i wskazuję na mój ekran startowy.

128
00:11:07,350 --> 00:11:11,490
Oznacza to, że to pierwsza rzecz, którą tu ładuję.

129
00:11:11,490 --> 00:11:17,010
Teraz na tym ekranie startowym przechodzę do ekranu autoryzacji, jeśli nie możemy znaleźć tokena,

130
00:11:17,010 --> 00:11:22,230
więc dzięki nawigatorowi przełączania opuszczam ten ekran i przechodzę do ekranu autoryzacji lub

131
00:11:22,230 --> 00:11:28,810
stosu autoryzacji, ponieważ nie mogę znaleźć token. Jeśli więc przejdziemy przez to, jeśli sprawdzimy, będziemy mieli przynajmniej jakieś dane, ale token

132
00:11:28,810 --> 00:11:29,950
nadal może być nieprawidłowy.

133
00:11:30,370 --> 00:11:39,980
Będziemy więc oczywiście mieć token, identyfikator użytkownika i datę ważności, którą możemy wyodrębnić z przekształconych danych po tym wierszu, tutaj z tą składnią

134
00:11:40,520 --> 00:11:42,770
destrukcyjną obiektu i są

135
00:11:43,600 --> 00:11:46,860
to trzy fragmenty danych o trzech dokładnie takich

136
00:11:46,870 --> 00:11:56,400
samych nazwach, jakie przechowuję tutaj w auth.

137
00:11:56,400 --> 00:11:56,400
plik js.

138
00:11:56,410 --> 00:12:00,700
Mamy więc obiekt z tokenem, identyfikatorem użytkownika

139
00:12:00,700 --> 00:12:03,000
i datą ważności,

140
00:12:03,010 --> 00:12:08,580
to właśnie przechowujemy w pamięci asynchronicznej, to mogę tutaj odzyskać.

141
00:12:08,610 --> 00:12:11,360
Teraz musimy sprawdzić, czy token jest nadal

142
00:12:11,460 --> 00:12:20,670
ważny. W tym celu mogę odtworzyć datę wygaśnięcia, używając nowej daty i przekazując datę wygaśnięcia, która w rzeczywistości jest ciągiem w formacie ISO, a

143
00:12:20,670 --> 00:12:23,220
teraz możemy dodać sprawdzanie if i

144
00:12:23,220 --> 00:12:27,270
sprawdzić, czy data wygaśnięcia, więc data, w której token staje

145
00:12:27,270 --> 00:12:33,660
się nieważny, jeśli jest mniejszy lub równy nowej dacie, co jest bieżącym znacznikiem czasu, co oznacza, że

146
00:12:33,660 --> 00:12:39,570
data wygaśnięcia jest w przeszłości, a jeśli jest w przeszłości, to nasz token jest nieprawidłowy.

147
00:12:40,320 --> 00:12:45,300
Jest również nieważny, jeśli nie możemy znaleźć tokena lub jeśli nie możemy

148
00:12:45,360 --> 00:12:51,900
znaleźć identyfikatora użytkownika, jeśli którykolwiek z trzech warunków jest spełniony, mamy nieprawidłowy token lub nieprawidłowy

149
00:12:51,900 --> 00:12:54,550
identyfikator użytkownika lub coś podobnego.

150
00:12:54,570 --> 00:12:58,700
W takim przypadku chcę też wrócić i

151
00:12:59,340 --> 00:13:05,640
oczywiście przejść do ekranu autoryzacji. Jeśli przejdziemy przez to, jeśli czek,

152
00:13:05,700 --> 00:13:10,110
mamy token, mamy identyfikator użytkownika, a token jest nadal ważny.

153
00:13:10,110 --> 00:13:17,720
Więc jeśli dasz radę tutaj, wywołam rekwizyty. nawigacja. nawiguj po sklepie, aby przejść do

154
00:13:17,720 --> 00:13:21,020
ekranu sklepu, a także ważne, muszę się zalogować i do

155
00:13:21,030 --> 00:13:24,230
tego potrzebujemy nowej akcji, ponieważ nie chcę teraz wysyłać

156
00:13:24,240 --> 00:13:29,900
żądania, chcę tylko zmienić niektóre dane w Redux. Dodam więc nowego twórcę akcji,

157
00:13:31,550 --> 00:13:44,200
może eksportuj stałe uwierzytelnianie, które może zabrać mój identyfikator użytkownika i mój token, a następnie służy do zmiany moich danych w Redux i do tego dodam

158
00:13:44,200 --> 00:13:45,250
teraz

159
00:13:45,250 --> 00:13:54,390
nowy identyfikator akcji, uwierzytelniając się za pomocą łańcucha uwierzytelnienia tutaj i użyj go tutaj jako uwierzytelnienia typu, dołącz mój

160
00:13:55,290 --> 00:14:02,190
identyfikator użytkownika, który jest moim identyfikatorem użytkownika, i mój token, który jest tokenem, który otrzymuję

161
00:14:02,190 --> 00:14:08,360
jako argument, a teraz to działanie uwierzytelnienia jest tym, co chcę wysłać tutaj

162
00:14:08,370 --> 00:14:09,600
na ekranie startowym.

163
00:14:10,730 --> 00:14:15,950
Ale zanim to zrobię, możemy również wrócić do twórcy akcji i pod koniec

164
00:14:15,950 --> 00:14:22,520
rejestracji, zamiast wysłać tutaj moją własną niestandardową akcję rejestracji, możemy również wysłać uwierzytelnienie i wykonać to

165
00:14:22,550 --> 00:14:23,390
tutaj,

166
00:14:23,510 --> 00:14:33,930
ten twórca akcji i po prostu przekaż resData. localId jako userId i resData. idToken jako token

167
00:14:33,950 --> 00:14:40,040
i zrób to samo na końcu logowania.

168
00:14:40,040 --> 00:14:45,400
Więc teraz rzeczywiście połączyłem te dwa przepływy, ponieważ w końcu to samo się dzieje, więc

169
00:14:45,560 --> 00:14:51,350
teraz w reduktorze, w reduktorze auth, oczywiście zamiast sprawdzania logowania i rejestracji, możemy po prostu zaimportować uwierzytelnianie

170
00:14:51,350 --> 00:14:57,780
i użyć tego identyfikatora tutaj, pozbyć się rejestracji, a ja po prostu skomentuję to, aby nadal ją tutaj wyświetlać

171
00:14:57,800 --> 00:15:00,830
w celach informacyjnych, ponieważ dzieje się to samo.

172
00:15:00,860 --> 00:15:05,980
Teraz połączenie tego ma sens, ponieważ potrzebujemy go również do automatycznego logowania.

173
00:15:06,020 --> 00:15:11,090
Więc tutaj wysyłam go również tutaj do ręcznego logowania i ręcznej rejestracji i

174
00:15:11,090 --> 00:15:17,150
oczywiście teraz, jeśli chcesz, możesz również pozbyć się logowania i zarejestrować się tutaj, tych dwóch

175
00:15:17,150 --> 00:15:20,200
identyfikatorów, ponieważ my nie użyj ich już.

176
00:15:20,390 --> 00:15:24,380
Ale dzięki temu, z powrotem do ekranu startowego,

177
00:15:24,600 --> 00:15:34,480
tutaj możemy teraz również wysłać to, a do tego wystarczy zaimportować use dispatch z React Redux i zaimportować akcję, więc zaimportuj wszystko jako

178
00:15:34,490 --> 00:15:41,650
akcje autoryzacji może z folderu sklepu, z folder akcji i z pliku auth tam, a następnie

179
00:15:41,650 --> 00:15:43,190
tutaj, na początku,

180
00:15:43,270 --> 00:15:49,590
uzyskaj dostęp do funkcji wysyłki, wywołując use dispatch, a przy tym dostępnym, tutaj możemy

181
00:15:49,800 --> 00:15:55,230
dodać wysyłkę jako zależność, ale to się nigdy nie zmieni, więc efekt

182
00:15:55,240 --> 00:16:01,330
nigdy się nie uruchomi ponownie a tutaj po przejściu do sklepu chcę teraz wysłać

183
00:16:01,450 --> 00:16:10,510
autoryzację i uwierzytelnić wyodrębnione ID użytkownika, więc to pole tutaj i wyodrębniony token, więc to pole, które otrzymałem z mojej pamięci

184
00:16:10,510 --> 00:16:19,150
asynchronicznej i które powinno teraz automatycznie mnie zalogować . To było dużo pracy, zobaczmy, czy

185
00:16:19,150 --> 00:16:24,310
to działa. Jeśli to przeładuję, skończę tutaj na ekranie logowania, ponieważ w

186
00:16:24,340 --> 00:16:27,010
tej chwili nie mam żadnych ważnych tokenów zapisanych w pamięci asynchronicznej.

187
00:16:27,880 --> 00:16:37,510
Więc teraz, jeśli spróbuję się zalogować tutaj, zostaniesz przekierowany, jeśli teraz przeładuję, znów skończę tutaj i to świetnie, ponieważ

188
00:16:37,510 --> 00:16:43,560
teraz oznacza to, że to działa i że token jest przechowywany.

189
00:16:43,730 --> 00:16:48,230
Teraz oczywiście byłoby miło, gdybyśmy mogli się wylogować, ponieważ w tej chwili nie ma

190
00:16:48,230 --> 00:16:49,070
takiej możliwości.