1

2025-08-18 17:12:04 +03:00
commit d84487d238
157 changed files with 160686 additions and 0 deletions
--- a/internal/services/distributor/crm_distributor.go
+++ b/internal/services/distributor/crm_distributor.go
@@ -0,0 +1,535 @@
+package distributor
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"git-molva.ru/Molva/molva-backend/services/api_gateway/internal/database"
+
+	dberrors "git-molva.ru/Molva/molva-backend/services/api_gateway/internal/database/errors"
+	dbtypes "git-molva.ru/Molva/molva-backend/services/api_gateway/internal/database/types"
+	rmodel "git-molva.ru/Molva/molva-backend/services/api_gateway/internal/request_model"
+)
+
+type CrmDistributorService struct {
+	dbClient database.Client
+}
+
+type CrmDistributorServiceConfig struct {
+	DbClient database.Client
+}
+
+func newCrmDistributorService(cfg CrmDistributorServiceConfig) *CrmDistributorService {
+	return &CrmDistributorService{
+		dbClient: cfg.DbClient,
+	}
+}
+
+func (s *CrmDistributorService) GetVacancyList(
+	ctx context.Context,
+	request *rmodel.VacancyListGetRequest,
+) (*rmodel.VacancyListGetResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	resp, err := s.dbClient.GetVacancyList(ctx, &dbtypes.VacancyListGetRequest{
+		Filters: &dbtypes.VacancyListFilters{
+			DistributorId: request.Filters.DistributorId,
+			CompanyId:     request.Filters.CompanyId,
+			VacancyId:     request.Filters.VacancyId,
+			Region:        request.Filters.Region,
+			SalaryBottom:  request.Filters.SalaryBottom,
+			SalaryTop:     request.Filters.SalaryTop,
+			IsArchived:    request.Filters.IsArchived,
+			Status:        dbtypes.NewVacancyStatus(request.Filters.Status.NullString()),
+		},
+		Page:     request.Page,
+		PageSize: request.PageSize,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("%w: error getting vacancy list: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.VacancyListGetResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) CreateVacancy(
+	ctx context.Context,
+	request *rmodel.VacancyCreateRequest,
+) (*rmodel.VacancyCreateResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	resp, err := s.dbClient.CreateVacancy(ctx, &dbtypes.VacancyCreateRequest{
+		CompanyId:        request.CompanyId,
+		Name:             request.Name,
+		Address:          request.Address,
+		WorkFormat:       request.WorkFormat,
+		AgentReward:      request.AgentReward,
+		SalaryTop:        request.SalaryTop,
+		SalaryBottom:     request.SalaryBottom,
+		Requirements:     request.Requirements,
+		Responsibilities: request.Responsibilities,
+		ExtraInfo:        request.ExtraInfo,
+		Region:           request.Region,
+		TargetAction: dbtypes.VacancyTargetAction{
+			Action:   request.TargetAction.Action,
+			Duration: request.TargetAction.Duration,
+		},
+		RequiredCandidates: request.RequiredCandidates,
+		CurrentCandidates:  request.CurrentCandidates,
+		ExtraFields:        request.ExtraFields,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("%w: error creating vacancy: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.VacancyCreateResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) UpdateVacancy(
+	ctx context.Context,
+	request *rmodel.VacancyUpdateRequest,
+) (*rmodel.VacancyUpdateResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	if _, err := s.dbClient.UpdateVacancy(ctx, &dbtypes.VacancyUpdateRequest{
+		Id:               request.Id,
+		Name:             request.Name,
+		Address:          request.Address,
+		WorkFormat:       request.WorkFormat,
+		AgentReward:      request.AgentReward,
+		SalaryTop:        request.SalaryTop,
+		SalaryBottom:     request.SalaryBottom,
+		Requirements:     request.Requirements,
+		Responsibilities: request.Responsibilities,
+		ExtraInfo:        request.ExtraInfo,
+		Region:           request.Region,
+		TargetAction: dbtypes.VacancyTargetActionForUpdate{
+			Action:   request.TargetAction.Action,
+			Duration: request.TargetAction.Duration,
+		},
+		RequiredCandidates: request.RequiredCandidates,
+		ExtraFields:        request.ExtraFields,
+	}); err != nil {
+		return nil, fmt.Errorf("%w: error updating vacancy: %v", s.handleDBError(err), err)
+	}
+
+	return &rmodel.VacancyUpdateResponse{}, nil
+}
+
+func (s *CrmDistributorService) DeleteVacancy(
+	ctx context.Context,
+	request *rmodel.VacancyDeleteRequest,
+) (*rmodel.VacancyDeleteResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	if _, err := s.dbClient.DeleteVacancy(ctx, &dbtypes.VacancyDeleteRequest{
+		Id: request.Id,
+	}); err != nil {
+		return nil, fmt.Errorf("%w: error deleting vacancy: %v", s.handleDBError(err), err)
+	}
+
+	return &rmodel.VacancyDeleteResponse{}, nil
+}
+
+func (s *CrmDistributorService) SendVacancyToModeration(
+	ctx context.Context,
+	request *rmodel.SendVacancyToModerationRequest,
+) (*rmodel.SendVacancyToModerationResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	if _, err := s.dbClient.SendVacancyToModeration(ctx, &dbtypes.SendVacancyToModerationRequest{
+		Id: request.Id,
+	}); err != nil {
+		return nil, fmt.Errorf("%w: error sending vacancy to moderation: %v", s.handleDBError(err), err)
+	}
+
+	return &rmodel.SendVacancyToModerationResponse{}, nil
+}
+
+func (s *CrmDistributorService) GetSubmissionListForVacancy(
+	ctx context.Context,
+	request *rmodel.SubmissionListForVacancyGetRequest,
+) (*rmodel.SubmissionListForVacancyGetResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	req := dbtypes.SubmissionListGetRequest{
+		Filters: &dbtypes.SubmissionListGetFilters{
+			VacancyId: &request.VacancyId,
+		},
+		Page:     request.Page,
+		PageSize: request.PageSize,
+	}
+
+	if request.Filters != nil {
+		req.Filters.Status = dbtypes.NewSubmissionStatus(request.Filters.Status.NullString())
+	}
+
+	resp, err := s.dbClient.GetSubmissionList(ctx, &req)
+	if err != nil {
+		return nil, fmt.Errorf("%w: error getting submission list: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.SubmissionListForVacancyGetResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) UpdateSubmissionStatus(
+	ctx context.Context,
+	request *rmodel.SubmissionStatusUpdateRequest,
+) (*rmodel.SubmissionStatusUpdateResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	if _, err := s.dbClient.UpdateSubmissionStatus(ctx, &dbtypes.SubmissionStatusUpdateRequest{
+		Id:     request.Id,
+		Status: *dbtypes.NewSubmissionStatus(request.Status.NullString()),
+	}); err != nil {
+		return nil, fmt.Errorf("%w: error updating submission status: %v", s.handleDBError(err), err)
+	}
+
+	return &rmodel.SubmissionStatusUpdateResponse{}, nil
+}
+
+func (s *CrmDistributorService) GetProfile(
+	ctx context.Context,
+	request *rmodel.ProfileGetRequest,
+) (*rmodel.ProfileGetResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	resp, err := s.dbClient.GetProfileById(ctx, &dbtypes.ProfileGetRequest{
+		Id: request.Id,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("%w: error getting user info: %v", ErrInternal, err)
+	}
+
+	result := new(rmodel.ProfileGetResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) UpdateProfile(
+	ctx context.Context,
+	request *rmodel.ProfileUpdateRequest,
+) (*rmodel.ProfileUpdateResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	if _, err := s.dbClient.UpdateProfile(ctx, &dbtypes.ProfileUpdateRequest{
+		Id:          request.Id,
+		Name:        request.Name,
+		PhoneNumber: request.PhoneNumber,
+		Email:       request.Email,
+	}); err != nil {
+		return nil, fmt.Errorf("%w: error updating profile: %v", s.handleDBError(err), err)
+	}
+
+	return &rmodel.ProfileUpdateResponse{}, nil
+}
+
+func (s *CrmDistributorService) GetCompanyList(
+	ctx context.Context,
+	request *rmodel.CompanyListGetRequest,
+) (*rmodel.CompanyListGetResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	resp, err := s.dbClient.GetCompanyList(ctx, &dbtypes.CompanyListGetRequest{
+		Id: request.Id,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("%w: error getting company list: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.CompanyListGetResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) GetCompanyInfoById(
+	ctx context.Context,
+	request *rmodel.CompanyByIdGetRequest,
+) (*rmodel.CompanyByIdGetResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	resp, err := s.dbClient.GetCompanyById(ctx, &dbtypes.CompanyByIdGetRequest{
+		Id:        request.UserId,
+		CompanyId: request.CompanyId,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("%w: error getting company info: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.CompanyByIdGetResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) CreateCompany(
+	ctx context.Context,
+	request *rmodel.CompanyCreateRequest,
+) (*rmodel.CompanyCreateResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	resp, err := s.dbClient.CreateCompany(ctx, &dbtypes.CompanyCreateRequest{
+		OwnerId:             request.OwnerId,
+		Name:                request.Name,
+		LegalPerson:         request.LegalPerson,
+		Description:         request.Description,
+		Website:             request.Website,
+		PhysicalAddress:     request.PhysicalAddress,
+		LegalAddress:        request.LegalAddress,
+		Inn:                 request.Inn,
+		Kpp:                 request.Kpp,
+		Staff:               request.Staff,
+		Metadata:            request.Metadata,
+		ExtraFieldsTemplate: request.ExtraFieldsTemplate,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("%w: error creating company: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.CompanyCreateResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) UpdateCompanyInfo(
+	ctx context.Context,
+	request *rmodel.CompanyUpdateRequest,
+) (*rmodel.CompanyUpdateResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	if _, err := s.dbClient.UpdateCompany(ctx, &dbtypes.CompanyUpdateRequest{
+		Id:              request.Id,
+		Name:            request.Name,
+		LegalPerson:     request.LegalPerson,
+		Description:     request.Description,
+		Website:         request.Website,
+		PhysicalAddress: request.PhysicalAddress,
+		LegalAddress:    request.LegalAddress,
+		Inn:             request.Inn,
+		Kpp:             request.Kpp,
+		Staff:           request.Staff,
+		Metadata:        request.Metadata,
+		ExtraFields:     request.ExtraFields,
+	}); err != nil {
+		return nil, fmt.Errorf("%w: error updating company info: %v", s.handleDBError(err), err)
+	}
+
+	return &rmodel.CompanyUpdateResponse{}, nil
+}
+
+func (s *CrmDistributorService) AddEmployee(
+	ctx context.Context,
+	request *rmodel.AddDistributorCompanyMemberRequest,
+) (*rmodel.AddDistributorCompanyMemberResponse, error) {
+	return nil, ErrUnimplemented
+}
+
+func (s *CrmDistributorService) GetBalance(
+	ctx context.Context,
+	request *rmodel.BalanceGetRequest,
+) (*rmodel.BalanceGetResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	resp, err := s.dbClient.GetBalance(ctx, &dbtypes.BalanceGetRequest{
+		OwnerId: request.OwnerId,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("%w: error getting balance: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.BalanceGetResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) GetTransactionList(
+	ctx context.Context,
+	request *rmodel.TransactionListGetRequest,
+) (*rmodel.TransactionListGetResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	req := dbtypes.TransactionListGetRequest{
+		OwnerId:  request.OwnerId,
+		Page:     request.Page,
+		PageSize: request.PageSize,
+	}
+
+	if request.Filters != nil {
+		req.Filters = new(dbtypes.TransactionListFilters)
+		req.Filters.Type = dbtypes.NewTransactionType(request.Filters.Type.NullString())
+		req.Filters.Status = dbtypes.NewTransactionStatus(request.Filters.Status.NullString())
+		req.Filters.BankAccountId = request.Filters.BankAccountId
+	}
+
+	resp, err := s.dbClient.GetTransactionList(ctx, &req)
+	if err != nil {
+		return nil, fmt.Errorf("%w: error getting transactions: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.TransactionListGetResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) CreateTransaction(
+	ctx context.Context,
+	request *rmodel.TransactionCreateRequest,
+) (*rmodel.TransactionCreateResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	req := dbtypes.TransactionCreateRequest{
+		OwnerId:       request.OwnerId,
+		Amount:        request.Amount,
+		Currency:      request.Currency,
+		BankAccountId: request.BankAccountId,
+		RequestId:     request.RequestId,
+	}
+
+	if request.Payload != nil {
+		req.Payload = &dbtypes.TransactionPayload{
+			Origin:      request.Payload.Origin,
+			CompanyId:   request.Payload.CompanyId,
+			CompanyName: request.Payload.CompanyName,
+			VacancyId:   request.Payload.VacancyId,
+			VacancyName: request.Payload.VacancyName,
+		}
+	}
+
+	resp, err := s.dbClient.CreateTransaction(ctx, &req)
+	if err != nil {
+		return nil, fmt.Errorf("%w: error creating transaction: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.TransactionCreateResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) GetBankAccountList(
+	ctx context.Context,
+	request *rmodel.BankAccountListGetRequest,
+) (*rmodel.BankAccountListGetResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	resp, err := s.dbClient.GetBankAccountList(ctx, &dbtypes.BankAccountListGetRequest{
+		OwnerId: request.OwnerId,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("%w: error getting bank accounts: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.BankAccountListGetResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) CreateBankAccount(
+	ctx context.Context,
+	request *rmodel.BankAccountCreateRequest,
+) (*rmodel.BankAccountCreateResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	resp, err := s.dbClient.CreateBankAccount(ctx, &dbtypes.BankAccountCreateRequest{
+		OwnerId:              request.OwnerId,
+		AccountNumber:        request.AccountNumber,
+		AccountName:          request.AccountName,
+		BankName:             request.BankName,
+		Bik:                  request.Bik,
+		CorrespondentAccount: request.CorrespondentAccount,
+		IsPrimary:            request.IsPrimary,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("%w: error creating bank account: %v", s.handleDBError(err), err)
+	}
+
+	result := new(rmodel.BankAccountCreateResponse).From(resp)
+
+	return result, nil
+}
+
+func (s *CrmDistributorService) UpdateBankAccount(
+	ctx context.Context,
+	request *rmodel.BankAccountUpdateRequest,
+) (*rmodel.BankAccountUpdateResponse, error) {
+	if err := request.Validate(); err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrBadRequest, err)
+	}
+
+	if _, err := s.dbClient.UpdateBankAccount(ctx, &dbtypes.BankAccountUpdateRequest{
+		Id:                   request.Id,
+		AccountNumber:        request.AccountNumber,
+		AccountName:          request.AccountName,
+		BankName:             request.BankName,
+		Bik:                  request.Bik,
+		CorrespondentAccount: request.CorrespondentAccount,
+		IsPrimary:            request.IsPrimary,
+	}); err != nil {
+		return nil, fmt.Errorf("%w: error updating bank account: %v", s.handleDBError(err), err)
+	}
+
+	return &rmodel.BankAccountUpdateResponse{}, nil
+}
+
+func (s *CrmDistributorService) DeleteBankAccount(
+	ctx context.Context,
+	request *rmodel.BankAccountDeleteRequest,
+) (*rmodel.BankAccountDeleteResponse, error) {
+	return nil, ErrUnimplemented
+}
+
+func (s *CrmDistributorService) handleDBError(err error) error {
+	switch {
+	case errors.Is(err, dberrors.ErrBadRequest):
+		return ErrBadRequest
+	case errors.Is(err, dberrors.ErrForbidden):
+		return ErrForbidden
+	case errors.Is(err, dberrors.ErrNotFound):
+		return ErrNotFound
+	case errors.Is(err, dberrors.ErrInternal):
+		return ErrInternal
+	default:
+		return ErrInternal
+	}
+}