Kita nambahake kemampuan kanggo langganan klompok artikel. (Bagian 2) - "Proyek Jawa saka A nganti Z"

Halo kabeh! Kita terus nggarap tugas sing diwiwiti minggu kepungkur .

Kita ngleksanakake JRTB-5

Saiki kita kudu nambah prentah supaya bisa langganan sawetara klompok artikel saka JavaRush. Carane nindakake? Kita bakal ngetutake skenario paling gampang sing dakkarepake. Amarga kita duwe akses kanthi ID grup, kita butuh pangguna kanggo nransfer. Kanggo nindakake iki, pangguna bakal ngetik printah / addGroupSub GROUP_ID, sing bakal bisa digunakake ing salah siji saka rong cara: yen mung printah dhewe teka: / addGroupSub , dhaptar kabeh grup lan ID sing dikirim minangka respon. Banjur pangguna bakal bisa milih ID grup sing dibutuhake lan nggawe panjalukan versi kapindho ing printah iki: / addGroupSub GROUP_ID - banjur bakal ana rekaman grup iki karo pangguna iki. Aku mikir kita bisa nindakake luwih apik ing mangsa ngarep. Tujuan kita yaiku kanggo nuduhake pangembangan, lan dudu pengalaman pangguna sing super keren (aku isin ngomong, nanging aku ora ngerti istilah ing basa Rusia sing tegese iki). Kanggo nambah fungsi kanthi bener sing ngliwati kabeh aplikasi (ing kasus kita, saka klien bot telegram menyang database), sampeyan kudu miwiti ing sawetara pungkasan. Kita bakal nindakake iki saka sisih database.

Nambahake migrasi anyar menyang database

Bab pisanan sing kudu ditindakake yaiku nambah migrasi database anyar lan kemampuan kanggo nyimpen data langganan grup pangguna ing JR. Kanggo ngelingi kepiye carane, bali menyang artikel " Perencanaan proyek: ukur kaping pitu ." Ana ing foto kapindho ana diagram kira-kira database. Kita kudu nambah tabel kanggo nyimpen informasi grup:

• ID grup ing JavaRush uga bakal dadi ID kita. Kita pitados lan pitados bilih ID punika unik;
• judhul - ing gambar kita iku jeneng - jeneng informal saka grup; yaiku, apa sing kita deleng ing situs web JavaRush;
• last_article_id - lan iki minangka lapangan sing menarik. Bakal nyimpen ID pungkasan artikel ing grup iki, sing bot wis dikirim menyang pelanggan. Nggunakake lapangan iki, mekanisme kanggo nggoleki artikel anyar bakal bisa digunakake. Pelanggan anyar ora bakal nampa artikel sing diterbitake sadurunge pangguna langganan: mung sing diterbitake sawise langganan grup.

Kita uga bakal duwe hubungan akeh-kanggo-akeh antarane grup lan tabel pangguna, amarga saben pangguna bisa duwe akeh langganan grup (siji-kanggo-akeh), lan saben langganan grup bisa duwe akeh pangguna (siji-kanggo- akeh, mung. ing sisih liyane). Pranyata iki bakal dadi akeh-kanggo-akeh kita. Kanggo sing duwe pitakonan, deleng artikel ing database. Ya, aku enggal ngrancang nggawe kiriman ing saluran Telegram, ing ngendi aku bakal nggabungake kabeh artikel ing basis data. Iki bakal katon kaya migrasi database kapindho.

V00002__created_groupsub_many_to_many.sql:

-- add PRIMARY KEY FOR tg_user
ALTER TABLE tg_user ADD PRIMARY KEY (chat_id);

-- ensure that the tables with these names are removed before creating a new one.
DROP TABLE IF EXISTS group_sub;
DROP TABLE IF EXISTS group_x_user;

CREATE TABLE group_sub (
   id INT,
   title VARCHAR(100),
   last_article_id INT,
   PRIMARY KEY (id)
);

CREATE TABLE group_x_user (
   group_sub_id INT NOT NULL,
   user_id VARCHAR(100) NOT NULL,
   FOREIGN KEY (user_id) REFERENCES tg_user(chat_id),
   FOREIGN KEY (group_sub_id) REFERENCES group_sub(id),
   UNIQUE(user_id, group_sub_id)
);

Wigati dimangerteni manawa pisanan aku ngganti tabel lawas - aku nambah kunci utama. Aku piye wae ora kejawab iki ing wektu, nanging saiki MySQL ora menehi kula kesempatan kanggo nambah FOREIGN KEY kanggo tabel gorup_x_user, lan minangka bagéan saka migrasi iki aku nganyari database. Wigati aspek penting. Ngganti basis data kudu ditindakake kanthi cara iki - kabeh sing dibutuhake ana ing migrasi anyar, nanging ora kanthi nganyari migrasi sing wis dirilis. Ya, ing kasus kita, ora ana sing bakal kelakon, amarga iki minangka proyek uji coba lan kita ngerti manawa mung disebar ing sak panggonan, nanging iki bakal dadi pendekatan sing salah. Nanging kita pengin kabeh bener. Sabanjure bakal mbusak tabel sadurunge nggawe. Kenapa iki? Dadi yen ana sawetara tabel kanthi jeneng kasebut ing basis data, migrasi ora bakal gagal lan bakal mlaku kaya sing dikarepake. Banjur kita nambah rong tabel. Kabeh kaya sing dikarepake. Saiki kita kudu miwiti aplikasi kita. Yen kabeh diwiwiti lan ora rusak, banjur migrasi dicathet. Lan kanggo mriksa kaping pindho iki, kita menyang database kanggo mesthekake yen: a) tabel kuwi wis katon; b) ana entri anyar ing tabel teknis flyway. Iki ngrampungake karya migrasi, ayo pindhah menyang repositori.

Nambahake lapisan repositori

Thanks kanggo Spring Boot Data, kabeh gampang banget ing kene: kita kudu nambah entitas GroupSub, rada nganyari TelegramUser lan nambah GroupSubRepository sing meh kosong: Kita nambah entitas GroupSub menyang paket sing padha karo TelegramUser:

package com.github.javarushcommunity.jrtb.repository.entity;

import lombok.Data;
import lombok.EqualsAndHashCode;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

import static java.util.Objects.isNull;

@Data
@Entity
@Table(name = "group_sub")
@EqualsAndHashCode
public class GroupSub {

   @Id
   private Integer id;

   @Column(name = "title")
   private String title;

   @Column(name = "last_article_id")
   private Integer lastArticleId;

   @ManyToMany(fetch = FetchType.EAGER)
   @JoinTable(
           name = "group_x_user",
           joinColumns = @JoinColumn(name = "group_sub_id"),
           inverseJoinColumns = @JoinColumn(name = "user_id")
   )
   private List<TelegramUser> users;

   public void addUser(TelegramUser telegramUser) {
       if (isNull(users)) {
           users = new ArrayList<>();
       }
       users.add(telegramUser);
   }
}

Siji bab sing kudu dicathet yaiku kita duwe lapangan pangguna tambahan sing bakal ngemot koleksi kabeh pangguna sing langganan grup kasebut. Lan rong anotasi - ManyToMany lan JoinTable - persis sing dibutuhake kanggo iki. Kolom sing padha kudu ditambahake kanggo TelegramUser:

@ManyToMany(mappedBy = "users", fetch = FetchType.EAGER)
private List<GroupSub> groupSubs;

Bidang iki nggunakake gabungan sing ditulis ing entitas GroupSub. Lan, nyatane, kelas repositori kanggo GroupSub yaiku GroupSubRepository :

package com.github.javarushcommunity.jrtb.repository;

import com.github.javarushcommunity.jrtb.repository.entity.GroupSub;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
* {@link Repository} for {@link GroupSub} entity.
*/
@Repository
public interface GroupSubRepository extends JpaRepository<GroupSub, Integer> {
}

Ing tahap iki, kita ora butuh cara tambahan: sing ditindakake ing leluhur JpaRepository cukup kanggo kita. Ayo nulis tes ing TelegramUserRepositoryIT sing bakal mriksa manawa akeh-kanggo-akeh karya kita. Ide tes kasebut yaiku kita bakal nambah 5 klompok langganan saben pangguna menyang database liwat skrip sql, entuk pangguna iki nganggo ID lan priksa manawa kita nampa persis klompok kasebut lan kanthi nilai sing padha. Carane nindakake? Sampeyan bisa nglebokake counter menyang data, sing banjur bisa dideleng lan dipriksa. Punika skrip fiveGroupSubsForUser.sql:

INSERT INTO tg_user VALUES (1, 1);

INSERT INTO group_sub VALUES
(1, 'g1', 1),
(2, 'g2', 2),
(3, 'g3', 3),
(4, 'g4', 4),
(5, 'g5', 5);

INSERT INTO group_x_user VALUES
(1, 1),
(2, 1),
(3, 1),
(4, 1),
(5, 1);

Lan tes kasebut dhewe:

@Sql(scripts = {"/sql/clearDbs.sql", "/sql/fiveGroupSubsForUser.sql"})
@Test
public void shouldProperlyGetAllGroupSubsForUser() {
   //when
   Optional<TelegramUser> userFromDB = telegramUserRepository.findById("1");

   //then
   Assertions.assertTrue(userFromDB.isPresent());
   List<GroupSub> groupSubs = userFromDB.get().getGroupSubs();
   for (int i = 0; i < groupSubs.size(); i++) {
       Assertions.assertEquals(String.format("g%s", (i + 1)), groupSubs.get(i).getTitle());
       Assertions.assertEquals(i + 1, groupSubs.get(i).getId());
       Assertions.assertEquals(i + 1, groupSubs.get(i).getLastArticleId());
   }
}

Saiki ayo nambahake tes kanthi makna sing padha kanggo entitas GroupSub. Kanggo nindakake iki, ayo nggawe kelas test groupSubRepositoryIT ing paket sing padha karo groupSubRepositoryIT :

package com.github.javarushcommunity.jrtb.repository;

import com.github.javarushcommunity.jrtb.repository.entity.GroupSub;
import com.github.javarushcommunity.jrtb.repository.entity.TelegramUser;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.jdbc.Sql;

import java.util.List;
import java.util.Optional;

import static org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase.Replace.NONE;

/**
* Integration-level testing for {@link GroupSubRepository}.
*/
@ActiveProfiles("test")
@DataJpaTest
@AutoConfigureTestDatabase(replace = NONE)
public class GroupSubRepositoryIT {

   @Autowired
   private GroupSubRepository groupSubRepository;

   @Sql(scripts = {"/sql/clearDbs.sql", "/sql/fiveUsersForGroupSub.sql"})
   @Test
   public void shouldProperlyGetAllUsersForGroupSub() {
       //when
       Optional<GroupSub> groupSubFromDB = groupSubRepository.findById(1);

       //then
       Assertions.assertTrue(groupSubFromDB.isPresent());
       Assertions.assertEquals(1, groupSubFromDB.get().getId());
       List<TelegramUser> users = groupSubFromDB.get().getUsers();
       for(int i=0; i<users.size(); i++) {
           Assertions.assertEquals(String.valueOf(i + 1), users.get(i).getChatId());
           Assertions.assertTrue(users.get(i).isActive());
       }
   }
}

Lan skrip fiveUsersForGroupSub.sql sing ilang:

INSERT INTO tg_user VALUES
(1, 1),
(2, 1),
(3, 1),
(4, 1),
(5, 1);

INSERT INTO group_sub VALUES (1, 'g1', 1);

INSERT INTO group_x_user VALUES
(1, 1),
(1, 2),
(1, 3),
(1, 4),
(1, 5);

Ing titik iki, bagean saka karya karo repositori bisa dianggep rampung. Saiki ayo nulis lapisan layanan.

Kita nulis GroupSubService

Ing tahap iki, kanggo nggarap klompok langganan, kita mung kudu bisa nyimpen, supaya ora masalah: kita nggawe layanan GroupSubService lan implementasine GroupSubServiceImpl ing paket sing ngemot layanan liyane - layanan:

package com.github.javarushcommunity.jrtb.service;

import com.github.javarushcommunity.jrtb.javarushclient.dto.GroupDiscussionInfo;
import com.github.javarushcommunity.jrtb.repository.entity.GroupSub;

/**
* Service for manipulating with {@link GroupSub}.
*/
public interface GroupSubService {

   GroupSub save(String chatId, GroupDiscussionInfo groupDiscussionInfo);
}

Lan implementasine:

package com.github.javarushcommunity.jrtb.service;

import com.github.javarushcommunity.jrtb.javarushclient.dto.GroupDiscussionInfo;
import com.github.javarushcommunity.jrtb.repository.GroupSubRepository;
import com.github.javarushcommunity.jrtb.repository.entity.GroupSub;
import com.github.javarushcommunity.jrtb.repository.entity.TelegramUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.ws.rs.NotFoundException;
import java.util.Optional;

@Service
public class GroupSubServiceImpl implements GroupSubService {

   private final GroupSubRepository groupSubRepository;
   private final TelegramUserService telegramUserService;

   @Autowired
   public GroupSubServiceImpl(GroupSubRepository groupSubRepository, TelegramUserService telegramUserService) {
       this.groupSubRepository = groupSubRepository;
       this.telegramUserService = telegramUserService;
   }

   @Override
   public GroupSub save(String chatId, GroupDiscussionInfo groupDiscussionInfo) {
       TelegramUser telegramUser = telegramUserService.findByChatId(chatId).orElseThrow(NotFoundException::new);
       //TODO add exception handling
       GroupSub groupSub;
       Optional<GroupSub> groupSubFromDB = groupSubRepository.findById(groupDiscussionInfo.getId());
       if(groupSubFromDB.isPresent()) {
           groupSub = groupSubFromDB.get();
           Optional<TelegramUser> first = groupSub.getUsers().stream()
                   .filter(it -> it.getChatId().equalsIgnoreCase(chatId))
                   .findFirst();
           if(first.isEmpty()) {
               groupSub.addUser(telegramUser);
           }
       } else {
           groupSub = new GroupSub();
           groupSub.addUser(telegramUser);
           groupSub.setId(groupDiscussionInfo.getId());
           groupSub.setTitle(groupDiscussionInfo.getTitle());
       }
       return groupSubRepository.save(groupSub);
   }
}

Supaya Data Spring bisa digunakake kanthi bener lan rekaman akeh-kanggo-akeh digawe, kita kudu njupuk pangguna saka database kanggo grup langganan sing digawe lan ditambahake menyang obyek GroupSub. Mangkono, nalika kita nransfer langganan iki kanggo nyimpen, sambungan uga bakal digawe liwat tabel group_x_user. Bisa uga ana kahanan nalika grup langganan kasebut wis digawe lan sampeyan mung kudu nambah pangguna liyane. Kanggo nindakake iki, pisanan njaluk ID grup saka database, lan yen ana rekaman, kita bisa karo, yen ora, nggawe anyar. Penting kanggo dicathet yen kanggo nggarap TelegramUser, kita nggunakake TelegramUserService kanggo ngetutake prinsip SOLID pungkasan. Ing wayahe, yen kita ora nemokake rekaman dening ID, Aku mung uncalan pangecualian. Saiki ora diproses kanthi cara apa wae: kita bakal nindakake iki ing pungkasan, sadurunge MVP. Ayo nulis rong tes unit kanggo kelas GroupSubServiceTest . Endi sing kita butuhake? Aku pengin mesthekake yen metode simpen bakal diarani ing GroupSubRepository lan entitas karo siji pangguna bakal dikirim menyang GroupSub - sing bakal ngasilake TelegramUserService menyang kita nggunakake ID sing diwenehake. Lan pilihan kaloro, nalika grup karo ID padha wis ing database lan grup iki wis duwe siji pangguna, lan sampeyan kudu mriksa sing pangguna liyane bakal ditambahake menyang grup iki lan obyek iki bakal disimpen. Mangkene implementasine:

package com.github.javarushcommunity.jrtb.service;

import com.github.javarushcommunity.jrtb.javarushclient.dto.GroupDiscussionInfo;
import com.github.javarushcommunity.jrtb.repository.GroupSubRepository;
import com.github.javarushcommunity.jrtb.repository.entity.GroupSub;
import com.github.javarushcommunity.jrtb.repository.entity.TelegramUser;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import java.util.Optional;

@DisplayName("Unit-level testing for GroupSubService")
public class GroupSubServiceTest {

   private GroupSubService groupSubService;
   private GroupSubRepository groupSubRepository;
   private TelegramUser newUser;

   private final static String CHAT_ID = "1";

   @BeforeEach
   public void init() {
       TelegramUserService telegramUserService = Mockito.mock(TelegramUserService.class);
       groupSubRepository = Mockito.mock(GroupSubRepository.class);
       groupSubService = new GroupSubServiceImpl(groupSubRepository, telegramUserService);

       newUser = new TelegramUser();
       newUser.setActive(true);
       newUser.setChatId(CHAT_ID);

       Mockito.when(telegramUserService.findByChatId(CHAT_ID)).thenReturn(Optional.of(newUser));
   }

   @Test
   public void shouldProperlySaveGroup() {
       //given

       GroupDiscussionInfo groupDiscussionInfo = new GroupDiscussionInfo();
       groupDiscussionInfo.setId(1);
       groupDiscussionInfo.setTitle("g1");

       GroupSub expectedGroupSub = new GroupSub();
       expectedGroupSub.setId(groupDiscussionInfo.getId());
       expectedGroupSub.setTitle(groupDiscussionInfo.getTitle());
       expectedGroupSub.addUser(newUser);

       //when
       groupSubService.save(CHAT_ID, groupDiscussionInfo);

       //then
       Mockito.verify(groupSubRepository).save(expectedGroupSub);
   }

   @Test
   public void shouldProperlyAddUserToExistingGroup() {
       //given
       TelegramUser oldTelegramUser = new TelegramUser();
       oldTelegramUser.setChatId("2");
       oldTelegramUser.setActive(true);

       GroupDiscussionInfo groupDiscussionInfo = new GroupDiscussionInfo();
       groupDiscussionInfo.setId(1);
       groupDiscussionInfo.setTitle("g1");

       GroupSub groupFromDB = new GroupSub();
       groupFromDB.setId(groupDiscussionInfo.getId());
       groupFromDB.setTitle(groupDiscussionInfo.getTitle());
       groupFromDB.addUser(oldTelegramUser);

       Mockito.when(groupSubRepository.findById(groupDiscussionInfo.getId())).thenReturn(Optional.of(groupFromDB));

       GroupSub expectedGroupSub = new GroupSub();
       expectedGroupSub.setId(groupDiscussionInfo.getId());
       expectedGroupSub.setTitle(groupDiscussionInfo.getTitle());
       expectedGroupSub.addUser(oldTelegramUser);
       expectedGroupSub.addUser(newUser);

       //when
       groupSubService.save(CHAT_ID, groupDiscussionInfo);

       //then
       Mockito.verify(groupSubRepository).findById(groupDiscussionInfo.getId());
       Mockito.verify(groupSubRepository).save(expectedGroupSub);
   }

}

Aku uga nambah metode init () karo anotasi BeforeEach. Kanthi cara iki, biasane nggawe metode sing bakal ditindakake sadurunge saben tes, lan bisa uga ana logika umum kanggo kabeh tes. Ing kasus kita, kita kudu ngunci TelegramUserService kanthi cara sing padha kanggo kabeh tes kelas iki, saengga bisa nransfer logika iki menyang cara sing umum. Ana rong desain mokito sing digunakake ing kene:

• Mockito.when(o1.m1(a1)).thenReturn(o2) - ing kono kita ngomong yen metode m1 diarani obyek o1 karo argumen a1 , metode kasebut bakal ngasilake obyek o2 . Iki meh fungsi paling penting saka mockito - kanggo meksa obyek mock bali persis apa kita kudu;

• Mockito.verify(o1).m1(a1) - kang verifikasi sing cara m1 diarani obyek o1 karo argumen a1 . Sampeyan bisa, mesthi, kanggo nggunakake obyek bali saka cara nyimpen, nanging aku mutusaké kanggo nggawe sethitik liyane rumit dening nuduhake cara liyane bisa. Nalika iku bisa migunani? Ing kasus ngendi cara kelas mock bali roso sepi. Banjur tanpa Mockito.verifikasi ora bakal ana karya)))

Kita terus netepi gagasan yen tes kudu ditulis, lan akeh sing kudu ditulis. Tahap sabanjure nggarap tim bot telegram.

Nggawe printah / addGroupSub

Ing kene kita kudu nindakake logika ing ngisor iki: yen kita mung nampa prentah, tanpa konteks, kita mbantu pangguna lan menehi dhaptar kabeh klompok kanthi ID supaya bisa ngirim informasi sing dibutuhake menyang bot. Lan yen pangguna ngirim printah menyang bot nganggo sawetara tembung liyane, golek grup sing nganggo ID kasebut utawa tulis yen ora ana grup kasebut. Ayo nambah nilai anyar ing ename kita - CommandName:

ADD_GROUP_SUB("/addgroupsub")

Ayo pindhah luwih saka database menyang bot telegram - nggawe kelas AddGroupSubCommand ing paket perintah:

package com.github.javarushcommunity.jrtb.command;

import com.github.javarushcommunity.jrtb.javarushclient.JavaRushGroupClient;
import com.github.javarushcommunity.jrtb.javarushclient.dto.GroupDiscussionInfo;
import com.github.javarushcommunity.jrtb.javarushclient.dto.GroupRequestArgs;
import com.github.javarushcommunity.jrtb.repository.entity.GroupSub;
import com.github.javarushcommunity.jrtb.service.GroupSubService;
import com.github.javarushcommunity.jrtb.service.SendBotMessageService;
import org.telegram.telegrambots.meta.api.objects.Update;

import java.util.stream.Collectors;

import static com.github.javarushcommunity.jrtb.command.CommandName.ADD_GROUP_SUB;
import static com.github.javarushcommunity.jrtb.command.CommandUtils.getChatId;
import static com.github.javarushcommunity.jrtb.command.CommandUtils.getMessage;
import static java.util.Objects.isNull;
import static org.apache.commons.lang3.StringUtils.SPACE;
import static org.apache.commons.lang3.StringUtils.isNumeric;

/**
* Add Group subscription {@link Command}.
*/
public class AddGroupSubCommand implements Command {

   private final SendBotMessageService sendBotMessageService;
   private final JavaRushGroupClient javaRushGroupClient;
   private final GroupSubService groupSubService;

   public AddGroupSubCommand(SendBotMessageService sendBotMessageService, JavaRushGroupClient javaRushGroupClient,
                             GroupSubService groupSubService) {
       this.sendBotMessageService = sendBotMessageService;
       this.javaRushGroupClient = javaRushGroupClient;
       this.groupSubService = groupSubService;
   }

   @Override
   public void execute(Update update) {
       if (getMessage(update).equalsIgnoreCase(ADD_GROUP_SUB.getCommandName())) {
           sendGroupIdList(getChatId(update));
           return;
       }
       String groupId = getMessage(update).split(SPACE)[1];
       String chatId = getChatId(update);
       if (isNumeric(groupId)) {
           GroupDiscussionInfo groupById = javaRushGroupClient.getGroupById(Integer.parseInt(groupId));
           if (isNull(groupById.getId())) {
               sendGroupNotFound(chatId, groupId);
           }
           GroupSub savedGroupSub = groupSubService.save(chatId, groupById);
           sendBotMessageService.sendMessage(chatId, "Подписал на группу " + savedGroupSub.getTitle());
       } else {
           sendGroupNotFound(chatId, groupId);
       }
   }

   private void sendGroupNotFound(String chatId, String groupId) {
       String groupNotFoundMessage = "Нет группы с ID = \"%s\"";
       sendBotMessageService.sendMessage(chatId, String.format(groupNotFoundMessage, groupId));
   }

   private void sendGroupIdList(String chatId) {
       String groupIds = javaRushGroupClient.getGroupList(GroupRequestArgs.builder().build()).stream()
               .map(group -> String.format("%s - %s \n", group.getTitle(), group.getId()))
               .collect(Collectors.joining());

       String message = "Whatбы подписаться на группу - передай комадну вместе с ID группы. \n" +
               "Например: /addGroupSub 16. \n\n" +
               "я подготовил список всех групп - выберай Howую хочешь :) \n\n" +
               "Name группы - ID группы \n\n" +
               "%s";

       sendBotMessageService.sendMessage(chatId, String.format(message, groupIds));
   }
}

Kelas iki nggunakake metode isNumeric saka perpustakaan apache-commons, supaya ditambahake ing memori kita:

<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-lang3</artifactId>
  <version>${apache.commons.version}</version>
</dependency>

Lan ing blok properti:

<apache.commons.version>3.11</apache.commons.version>

Kabeh logika iki ana ing kelas. Wacanen kanthi ati-ati. Yen sampeyan duwe pitakon / saran, tulisake ing komentar. Sawise iki, kita kudu nambah printah menyang CommandContainer ing peta printah kita:

.put(ADD_GROUP_SUB.getCommandName(), new AddGroupSubCommand(sendBotMessageService, javaRushGroupClient, groupSubService))

Lan kabeh kanggo tim iki. Aku kaya kanggo piye wae nyoba fungsi iki, nanging nganti saiki aku mung bisa tenan katon ing database. Ing bagean telu, aku bakal nambah owah-owahan saka JRTB-6 supaya kita bisa ndeleng dhaptar grup sing pangguna langganan. Saiki luwih becik mriksa kabeh iki. Kanggo nindakake iki, kita bakal nindakake kabeh tumindak ing Telegram lan mriksa ing database. Amarga kita duwe tes tulis, kabeh kudu apik. Artikel wis cukup dawa, supaya kita bakal nulis test kanggo AddGroupSubCommand mengko, lan nambah TODO ing kode supaya ora lali.

kesimpulan

Ing artikel iki, kita ndeleng karya nambah fungsionalitas liwat kabeh aplikasi, wiwit saka database lan dipungkasi karo klien sing nggunakake bot. Biasane tugas-tugas kasebut mbantu ngerti proyek kasebut lan ngerti esensie. Ngerti cara kerjane. Dina iki topik ora gampang, mula aja isin: tulis pitakonan sampeyan ing komentar, lan aku bakal nyoba mangsuli. Apa sampeyan seneng proyek kasebut? Menehi lintang ing Github : kanthi cara iki bakal cetha yen dheweke kasengsem ing proyek kasebut, lan aku bakal seneng. Kaya sing dikandhakake, master mesthi seneng yen karyane diapresiasi. Kode kasebut bakal ngemot kabeh telung bagean STEP_6 lan bakal kasedhiya sadurunge artikel iki. Kepiye carane ngerteni babagan iki? Gampang - gabung karo saluran telegram , ing ngendi aku nerbitake kabeh informasi babagan artikelku babagan bot telegram. Matur nuwun kanggo maca! Part 3 wis ana .

Dhaptar kabeh materi ing seri kasebut ana ing wiwitan artikel iki.