diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index fe4415d8a69..168603a63c4 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -46,9 +46,9 @@ variables: RUNNER_TAG: &runner_tag milmove DOCKER_RUNNER_TAG: &docker_runner_tag eks_cluster_runner - postgres: &postgres postgres:16.4 + postgres: &postgres harbor.csde.caci.com/docker.io/postgres:16.4 #postgres: &postgres postgres:16.4 - redis: &redis redis:5.0.6 + redis: &redis harbor.csde.caci.com/docker.io/redis:5.0.6 stages: - pre_checks @@ -86,6 +86,10 @@ stages: .setup_aws_vars_dp3: &setup_aws_vars_dp3 - export SERVICE_RESERVATION_CPU=2048 - export SERVICE_RESERVATION_MEM=4096 + - unset AWS_ACCESS_KEY_ID + - unset AWS_SECRET_ACCESS_KEY + - unset AWS_ACCOUNT_ID + - unset AWS_DEFAULT_REGION - | if [[ "$DP3_ENV" == "exp" || "$DP3_ENV" == "loadtest" || "$DP3_ENV" == "demo" ]]; then export ENV=$(echo ${DP3_ENV} | tr '[:lower:]' '[:upper:]'); @@ -108,12 +112,20 @@ stages: fi .setup_aws_vars_com_dev: &setup_aws_vars_com_dev + - unset AWS_ACCESS_KEY_ID + - unset AWS_SECRET_ACCESS_KEY + - unset AWS_ACCOUNT_ID + - unset AWS_DEFAULT_REGION - export AWS_DEFAULT_REGION=$COM_REGION - export AWS_ACCOUNT_ID=$DEV_ACCOUNT_ID - export AWS_ACCESS_KEY_ID=$DEV_ACCESS_KEY_ID - export AWS_SECRET_ACCESS_KEY=$DEV_SECRET_KEY .setup_aws_vars_stg: &setup_aws_vars_stg + - unset AWS_ACCESS_KEY_ID + - unset AWS_SECRET_ACCESS_KEY + - unset AWS_ACCOUNT_ID + - unset AWS_DEFAULT_REGION - export AWS_DEFAULT_REGION=$STG_REGION - export AWS_ACCOUNT_ID=$STG_ACCOUNT_ID - export AWS_ACCESS_KEY_ID=$STG_ACCESS_KEY_ID @@ -127,6 +139,10 @@ stages: - export TLS_CA=$STG_MOVE_MIL_DOD_TLS_CA .setup_aws_vars_prd: &setup_aws_vars_prd + - unset AWS_ACCESS_KEY_ID + - unset AWS_SECRET_ACCESS_KEY + - unset AWS_ACCOUNT_ID + - unset AWS_DEFAULT_REGION - export AWS_DEFAULT_REGION=$PRD_REGION - export AWS_ACCOUNT_ID=$PRD_ACCOUNT_ID - export AWS_ACCESS_KEY_ID=$PRD_ACCESS_KEY_ID @@ -405,7 +421,7 @@ golang_lint: interruptible: true tags: - $DOCKER_RUNNER_TAG - image: golangci/golangci-lint:latest # Refer to https://hub.docker.com/r/golangci/golangci-lint + image: harbor.csde.caci.com/docker.io/golangci/golangci-lint:latest # Refer to https://hub.docker.com/r/golangci/golangci-lint script: - golangci-lint run --print-issued-lines=false --timeout=25m --out-format code-climate:gl-code-quality-report.json,line-number artifacts: @@ -750,7 +766,6 @@ pre_test: - yarn danger ci --failOnErrors - echo "Run spectral linter on all files" - ./scripts/ensure-spectral-lint /tmp/spectral_baseline spectral - allow_failure: true after_script: - *announce_failure artifacts: @@ -761,8 +776,12 @@ pre_test: - tmp/spectral_baseline/*.json #what do we need to store for review? - spectral/*.json #what do we need to store for review? when: always - # rules: - # - *check_server_ignore_branch + rules: + - if: '$PRE_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$PRE_TEST_ALLOW_FAILURE == "false"' + allow_failure: false + # - *check_server_ignore_branch all branches for now server_test: stage: test @@ -835,7 +854,6 @@ server_test: - echo "server test -- build gotestsum and run scripts for report" - make -j 2 bin/milmove bin/gotestsum - make server_test - allow_failure: false artifacts: paths: - /builds/milmove/mymove/bin/gotestsum @@ -845,9 +863,12 @@ server_test: junit: /builds/milmove/mymove/tmp/test-results/gotest/app/go-test-report.xml after_script: - *announce_failure - # we want to make this run on every branch bc webhooks don't exist currently - # rules: - # - *check_server_ignore_branch + rules: + - if: '$SERVER_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$SERVER_TEST_ALLOW_FAILURE == "false"' + allow_failure: false + # - *check_server_ignore_branch # we want to make this run on every branch bc webhooks don't exist currently server_test_coverage: stage: test @@ -867,10 +888,13 @@ server_test_coverage: ./scripts/ensure-go-test-coverage \ tmp/baseline-go-coverage/go-coverage.txt \ tmp/test-results/gotest/app/go-coverage.txt - allow_failure: true after_script: - *announce_failure rules: + - if: '$SERVER_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$SERVER_TEST_ALLOW_FAILURE == "false"' + allow_failure: true #allow failure for now - *check_server_ignore_branch ###may need to rethink the logic and intent of this they save per the following and do some PR interaction # only save the cache on default branch builds because we only want to @@ -914,9 +938,12 @@ client_test: - /builds/milmove/mymove/jest-junit-reports after_script: - *announce_failure - # we want to make this run on every branch bc webhooks don't exist currently - # rules: - # - *check_client_ignore_branch + rules: + - if: '$CLIENT_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$CLIENT_TEST_ALLOW_FAILURE == "false"' + allow_failure: false + # - *check_client_ignore_branch # we want to make this run on every branch bc webhooks don't exist currently client_test_coverage: stage: test @@ -940,6 +967,10 @@ client_test_coverage: after_script: - *announce_failure rules: + - if: '$CLIENT_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$CLIENT_TEST_ALLOW_FAILURE == "false"' + allow_failure: true #allow failure for now - *check_client_ignore_branch integration_test_devseed: @@ -995,10 +1026,13 @@ integration_test_devseed: export MOVE_MIL_DOD_TLS_CERT=$(cat config/tls/devlocal-https.pem) export MOVE_MIL_DOD_TLS_KEY=$(cat config/tls/devlocal-https.key) - make db_dev_fresh - allow_failure: true after_script: - *announce_failure rules: + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "false"' + allow_failure: false - *check_integration_ignore_branch integration_tests: @@ -1020,10 +1054,13 @@ integration_tests: script: - echo "TODO Add steps" - echo "integration_tests" - allow_failure: true after_script: - *announce_failure rules: + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "false"' + allow_failure: true # allow failure for now - *check_integration_ignore_branch integration_test_mtls: @@ -1082,10 +1119,13 @@ integration_test_mtls: paths: - test-results/ when: always - allow_failure: true after_script: - *announce_failure rules: + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "false"' + allow_failure: true # allow failure for now - *check_integration_mtls_ignore_branch integration_test_admin: @@ -1149,10 +1189,13 @@ integration_test_admin: - complete-playwright-report.zip - playwright-results.xml when: always - allow_failure: true after_script: - *announce_failure rules: + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "false"' + allow_failure: true # allow failure for now - *check_integration_ignore_branch integration_test_my: @@ -1217,10 +1260,13 @@ integration_test_my: - complete-playwright-report.zip - playwright-results.xml when: always - allow_failure: true after_script: - *announce_failure rules: + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "false"' + allow_failure: true # allow failure for now - *check_integration_ignore_branch integration_test_office: @@ -1283,10 +1329,13 @@ integration_test_office: - complete-playwright-report.zip - playwright-results.xml when: always - allow_failure: true after_script: - *announce_failure rules: + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "true"' + allow_failure: true + - if: '$INTEGRATION_TEST_ALLOW_FAILURE == "false"' + allow_failure: true # allow failure for now - *check_integration_ignore_branch @@ -1560,7 +1609,6 @@ deploy_app_dp3: ######################################################## ## STG push and deploy stages all off of main only ## ######################################################## - build_push_app_stg: stage: push interruptible: true @@ -1573,6 +1621,10 @@ build_push_app_stg: needs: - compile_app_client - compile_app_server + - client_test_coverage + - server_test_coverage + - pre_test + - integration_tests before_script: - *setup_aws_vars_stg - *setup_release_stg @@ -1597,6 +1649,10 @@ build_push_migrations_stg: needs: - compile_app_server - compile_app_client + - client_test_coverage + - server_test_coverage + - pre_test + - integration_tests before_script: - *setup_aws_vars_stg - *setup_release_stg @@ -1621,6 +1677,10 @@ build_push_tasks_stg: needs: - compile_app_server - compile_app_client + - client_test_coverage + - server_test_coverage + - pre_test + - integration_tests before_script: - *setup_aws_vars_stg - *setup_release_stg diff --git a/pkg/gen/primeapi/configure_mymove.go b/pkg/gen/primeapi/configure_mymove.go index 6def1f8afbc..54439004657 100644 --- a/pkg/gen/primeapi/configure_mymove.go +++ b/pkg/gen/primeapi/configure_mymove.go @@ -51,6 +51,11 @@ func configureAPI(api *primeoperations.MymoveAPI) http.Handler { // You may change here the memory limit for this multipart form parser. Below is the default (32 MB). // payment_request.CreateUploadMaxParseMemory = 32 << 20 + if api.MoveTaskOrderAcknowledgeMovesAndShipmentsHandler == nil { + api.MoveTaskOrderAcknowledgeMovesAndShipmentsHandler = move_task_order.AcknowledgeMovesAndShipmentsHandlerFunc(func(params move_task_order.AcknowledgeMovesAndShipmentsParams) middleware.Responder { + return middleware.NotImplemented("operation move_task_order.AcknowledgeMovesAndShipments has not yet been implemented") + }) + } if api.MoveTaskOrderCreateExcessWeightRecordHandler == nil { api.MoveTaskOrderCreateExcessWeightRecordHandler = move_task_order.CreateExcessWeightRecordHandlerFunc(func(params move_task_order.CreateExcessWeightRecordParams) middleware.Responder { return middleware.NotImplemented("operation move_task_order.CreateExcessWeightRecord has not yet been implemented") diff --git a/pkg/gen/primeapi/embedded_spec.go b/pkg/gen/primeapi/embedded_spec.go index 414c6510ea5..664804d6c61 100644 --- a/pkg/gen/primeapi/embedded_spec.go +++ b/pkg/gen/primeapi/embedded_spec.go @@ -74,6 +74,46 @@ func init() { } } }, + "/move-task-orders/acknowledge": { + "patch": { + "description": "### Functionality\nThis endpoint **updates** the Moves and Shipments to indicate that the Prime has acknowledged the Moves and Shipments have been received.\nThe Move and Shipment data is expected to be sent in the request body.\n", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "moveTaskOrder" + ], + "summary": "acknowledgeMovesAndShipments", + "operationId": "acknowledgeMovesAndShipments", + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/AcknowledgeMoves" + } + } + ], + "responses": { + "200": { + "description": "Successfully updated Move and Shipment Acknowledgements.", + "schema": { + "$ref": "#/definitions/AcknowledgeMovesShipmentsSuccessResponse" + } + }, + "422": { + "$ref": "#/responses/UnprocessableEntity" + }, + "500": { + "$ref": "#/responses/ServerError" + } + } + } + }, "/move-task-orders/{moveID}": { "get": { "description": "### Functionality\nThis endpoint gets an individual MoveTaskOrder by ID.\n\nIt will provide information about the Customer and any associated MTOShipments, MTOServiceItems and PaymentRequests.\n", @@ -1222,6 +1262,57 @@ func init() { } }, "definitions": { + "AcknowledgeMove": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uuid", + "example": "a502b4f1-b9c4-4faf-8bdd-68292501bf26" + }, + "mtoShipments": { + "type": "array", + "items": { + "$ref": "#/definitions/AcknowledgeShipment" + } + }, + "primeAcknowledgedAt": { + "type": "string", + "format": "date-time", + "example": "2025-04-13T14:15:22Z" + } + } + }, + "AcknowledgeMoves": { + "type": "array", + "items": { + "$ref": "#/definitions/AcknowledgeMove" + } + }, + "AcknowledgeMovesShipmentsSuccessResponse": { + "type": "object", + "properties": { + "message": { + "type": "string", + "example": "Moves/Shipments acknowledgement successfully completed" + } + } + }, + "AcknowledgeShipment": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uuid", + "example": "1f2270c7-7166-40ae-981e-b200ebdf3054" + }, + "primeAcknowledgedAt": { + "type": "string", + "format": "date-time", + "example": "2025-04-13T14:15:33Z" + } + } + }, "Address": { "description": "A postal address", "type": "object", @@ -5263,6 +5354,52 @@ func init() { } } }, + "/move-task-orders/acknowledge": { + "patch": { + "description": "### Functionality\nThis endpoint **updates** the Moves and Shipments to indicate that the Prime has acknowledged the Moves and Shipments have been received.\nThe Move and Shipment data is expected to be sent in the request body.\n", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "moveTaskOrder" + ], + "summary": "acknowledgeMovesAndShipments", + "operationId": "acknowledgeMovesAndShipments", + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/AcknowledgeMoves" + } + } + ], + "responses": { + "200": { + "description": "Successfully updated Move and Shipment Acknowledgements.", + "schema": { + "$ref": "#/definitions/AcknowledgeMovesShipmentsSuccessResponse" + } + }, + "422": { + "description": "The request was unprocessable, likely due to bad input from the requester.", + "schema": { + "$ref": "#/definitions/ValidationError" + } + }, + "500": { + "description": "A server error occurred.", + "schema": { + "$ref": "#/definitions/Error" + } + } + } + } + }, "/move-task-orders/{moveID}": { "get": { "description": "### Functionality\nThis endpoint gets an individual MoveTaskOrder by ID.\n\nIt will provide information about the Customer and any associated MTOShipments, MTOServiceItems and PaymentRequests.\n", @@ -6783,6 +6920,57 @@ func init() { } }, "definitions": { + "AcknowledgeMove": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uuid", + "example": "a502b4f1-b9c4-4faf-8bdd-68292501bf26" + }, + "mtoShipments": { + "type": "array", + "items": { + "$ref": "#/definitions/AcknowledgeShipment" + } + }, + "primeAcknowledgedAt": { + "type": "string", + "format": "date-time", + "example": "2025-04-13T14:15:22Z" + } + } + }, + "AcknowledgeMoves": { + "type": "array", + "items": { + "$ref": "#/definitions/AcknowledgeMove" + } + }, + "AcknowledgeMovesShipmentsSuccessResponse": { + "type": "object", + "properties": { + "message": { + "type": "string", + "example": "Moves/Shipments acknowledgement successfully completed" + } + } + }, + "AcknowledgeShipment": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uuid", + "example": "1f2270c7-7166-40ae-981e-b200ebdf3054" + }, + "primeAcknowledgedAt": { + "type": "string", + "format": "date-time", + "example": "2025-04-13T14:15:33Z" + } + } + }, "Address": { "description": "A postal address", "type": "object", diff --git a/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments.go b/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments.go new file mode 100644 index 00000000000..85e6b6ad442 --- /dev/null +++ b/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments.go @@ -0,0 +1,60 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package move_task_order + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the generate command + +import ( + "net/http" + + "github.com/go-openapi/runtime/middleware" +) + +// AcknowledgeMovesAndShipmentsHandlerFunc turns a function with the right signature into a acknowledge moves and shipments handler +type AcknowledgeMovesAndShipmentsHandlerFunc func(AcknowledgeMovesAndShipmentsParams) middleware.Responder + +// Handle executing the request and returning a response +func (fn AcknowledgeMovesAndShipmentsHandlerFunc) Handle(params AcknowledgeMovesAndShipmentsParams) middleware.Responder { + return fn(params) +} + +// AcknowledgeMovesAndShipmentsHandler interface for that can handle valid acknowledge moves and shipments params +type AcknowledgeMovesAndShipmentsHandler interface { + Handle(AcknowledgeMovesAndShipmentsParams) middleware.Responder +} + +// NewAcknowledgeMovesAndShipments creates a new http.Handler for the acknowledge moves and shipments operation +func NewAcknowledgeMovesAndShipments(ctx *middleware.Context, handler AcknowledgeMovesAndShipmentsHandler) *AcknowledgeMovesAndShipments { + return &AcknowledgeMovesAndShipments{Context: ctx, Handler: handler} +} + +/* + AcknowledgeMovesAndShipments swagger:route PATCH /move-task-orders/acknowledge moveTaskOrder acknowledgeMovesAndShipments + +acknowledgeMovesAndShipments + +### Functionality +This endpoint **updates** the Moves and Shipments to indicate that the Prime has acknowledged the Moves and Shipments have been received. +The Move and Shipment data is expected to be sent in the request body. +*/ +type AcknowledgeMovesAndShipments struct { + Context *middleware.Context + Handler AcknowledgeMovesAndShipmentsHandler +} + +func (o *AcknowledgeMovesAndShipments) ServeHTTP(rw http.ResponseWriter, r *http.Request) { + route, rCtx, _ := o.Context.RouteInfo(r) + if rCtx != nil { + *r = *rCtx + } + var Params = NewAcknowledgeMovesAndShipmentsParams() + if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params + o.Context.Respond(rw, r, route.Produces, route, err) + return + } + + res := o.Handler.Handle(Params) // actually handle the request + o.Context.Respond(rw, r, route.Produces, route, res) + +} diff --git a/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments_parameters.go b/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments_parameters.go new file mode 100644 index 00000000000..6880d54a490 --- /dev/null +++ b/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments_parameters.go @@ -0,0 +1,84 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package move_task_order + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "io" + "net/http" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + "github.com/go-openapi/runtime/middleware" + "github.com/go-openapi/validate" + + "github.com/transcom/mymove/pkg/gen/primemessages" +) + +// NewAcknowledgeMovesAndShipmentsParams creates a new AcknowledgeMovesAndShipmentsParams object +// +// There are no default values defined in the spec. +func NewAcknowledgeMovesAndShipmentsParams() AcknowledgeMovesAndShipmentsParams { + + return AcknowledgeMovesAndShipmentsParams{} +} + +// AcknowledgeMovesAndShipmentsParams contains all the bound params for the acknowledge moves and shipments operation +// typically these are obtained from a http.Request +// +// swagger:parameters acknowledgeMovesAndShipments +type AcknowledgeMovesAndShipmentsParams struct { + + // HTTP Request Object + HTTPRequest *http.Request `json:"-"` + + /* + Required: true + In: body + */ + Body primemessages.AcknowledgeMoves +} + +// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface +// for simple values it will use straight method calls. +// +// To ensure default values, the struct must have been initialized with NewAcknowledgeMovesAndShipmentsParams() beforehand. +func (o *AcknowledgeMovesAndShipmentsParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { + var res []error + + o.HTTPRequest = r + + if runtime.HasBody(r) { + defer r.Body.Close() + var body primemessages.AcknowledgeMoves + if err := route.Consumer.Consume(r.Body, &body); err != nil { + if err == io.EOF { + res = append(res, errors.Required("body", "body", "")) + } else { + res = append(res, errors.NewParseError("body", "body", "", err)) + } + } else { + // validate body object + if err := body.Validate(route.Formats); err != nil { + res = append(res, err) + } + + ctx := validate.WithOperationRequest(r.Context()) + if err := body.ContextValidate(ctx, route.Formats); err != nil { + res = append(res, err) + } + + if len(res) == 0 { + o.Body = body + } + } + } else { + res = append(res, errors.Required("body", "body", "")) + } + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments_responses.go b/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments_responses.go new file mode 100644 index 00000000000..4f4c4429653 --- /dev/null +++ b/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments_responses.go @@ -0,0 +1,149 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package move_task_order + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + + "github.com/go-openapi/runtime" + + "github.com/transcom/mymove/pkg/gen/primemessages" +) + +// AcknowledgeMovesAndShipmentsOKCode is the HTTP code returned for type AcknowledgeMovesAndShipmentsOK +const AcknowledgeMovesAndShipmentsOKCode int = 200 + +/* +AcknowledgeMovesAndShipmentsOK Successfully updated Move and Shipment Acknowledgements. + +swagger:response acknowledgeMovesAndShipmentsOK +*/ +type AcknowledgeMovesAndShipmentsOK struct { + + /* + In: Body + */ + Payload *primemessages.AcknowledgeMovesShipmentsSuccessResponse `json:"body,omitempty"` +} + +// NewAcknowledgeMovesAndShipmentsOK creates AcknowledgeMovesAndShipmentsOK with default headers values +func NewAcknowledgeMovesAndShipmentsOK() *AcknowledgeMovesAndShipmentsOK { + + return &AcknowledgeMovesAndShipmentsOK{} +} + +// WithPayload adds the payload to the acknowledge moves and shipments o k response +func (o *AcknowledgeMovesAndShipmentsOK) WithPayload(payload *primemessages.AcknowledgeMovesShipmentsSuccessResponse) *AcknowledgeMovesAndShipmentsOK { + o.Payload = payload + return o +} + +// SetPayload sets the payload to the acknowledge moves and shipments o k response +func (o *AcknowledgeMovesAndShipmentsOK) SetPayload(payload *primemessages.AcknowledgeMovesShipmentsSuccessResponse) { + o.Payload = payload +} + +// WriteResponse to the client +func (o *AcknowledgeMovesAndShipmentsOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) { + + rw.WriteHeader(200) + if o.Payload != nil { + payload := o.Payload + if err := producer.Produce(rw, payload); err != nil { + panic(err) // let the recovery middleware deal with this + } + } +} + +// AcknowledgeMovesAndShipmentsUnprocessableEntityCode is the HTTP code returned for type AcknowledgeMovesAndShipmentsUnprocessableEntity +const AcknowledgeMovesAndShipmentsUnprocessableEntityCode int = 422 + +/* +AcknowledgeMovesAndShipmentsUnprocessableEntity The request was unprocessable, likely due to bad input from the requester. + +swagger:response acknowledgeMovesAndShipmentsUnprocessableEntity +*/ +type AcknowledgeMovesAndShipmentsUnprocessableEntity struct { + + /* + In: Body + */ + Payload *primemessages.ValidationError `json:"body,omitempty"` +} + +// NewAcknowledgeMovesAndShipmentsUnprocessableEntity creates AcknowledgeMovesAndShipmentsUnprocessableEntity with default headers values +func NewAcknowledgeMovesAndShipmentsUnprocessableEntity() *AcknowledgeMovesAndShipmentsUnprocessableEntity { + + return &AcknowledgeMovesAndShipmentsUnprocessableEntity{} +} + +// WithPayload adds the payload to the acknowledge moves and shipments unprocessable entity response +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) WithPayload(payload *primemessages.ValidationError) *AcknowledgeMovesAndShipmentsUnprocessableEntity { + o.Payload = payload + return o +} + +// SetPayload sets the payload to the acknowledge moves and shipments unprocessable entity response +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) SetPayload(payload *primemessages.ValidationError) { + o.Payload = payload +} + +// WriteResponse to the client +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) { + + rw.WriteHeader(422) + if o.Payload != nil { + payload := o.Payload + if err := producer.Produce(rw, payload); err != nil { + panic(err) // let the recovery middleware deal with this + } + } +} + +// AcknowledgeMovesAndShipmentsInternalServerErrorCode is the HTTP code returned for type AcknowledgeMovesAndShipmentsInternalServerError +const AcknowledgeMovesAndShipmentsInternalServerErrorCode int = 500 + +/* +AcknowledgeMovesAndShipmentsInternalServerError A server error occurred. + +swagger:response acknowledgeMovesAndShipmentsInternalServerError +*/ +type AcknowledgeMovesAndShipmentsInternalServerError struct { + + /* + In: Body + */ + Payload *primemessages.Error `json:"body,omitempty"` +} + +// NewAcknowledgeMovesAndShipmentsInternalServerError creates AcknowledgeMovesAndShipmentsInternalServerError with default headers values +func NewAcknowledgeMovesAndShipmentsInternalServerError() *AcknowledgeMovesAndShipmentsInternalServerError { + + return &AcknowledgeMovesAndShipmentsInternalServerError{} +} + +// WithPayload adds the payload to the acknowledge moves and shipments internal server error response +func (o *AcknowledgeMovesAndShipmentsInternalServerError) WithPayload(payload *primemessages.Error) *AcknowledgeMovesAndShipmentsInternalServerError { + o.Payload = payload + return o +} + +// SetPayload sets the payload to the acknowledge moves and shipments internal server error response +func (o *AcknowledgeMovesAndShipmentsInternalServerError) SetPayload(payload *primemessages.Error) { + o.Payload = payload +} + +// WriteResponse to the client +func (o *AcknowledgeMovesAndShipmentsInternalServerError) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) { + + rw.WriteHeader(500) + if o.Payload != nil { + payload := o.Payload + if err := producer.Produce(rw, payload); err != nil { + panic(err) // let the recovery middleware deal with this + } + } +} diff --git a/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments_urlbuilder.go b/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments_urlbuilder.go new file mode 100644 index 00000000000..18d63784845 --- /dev/null +++ b/pkg/gen/primeapi/primeoperations/move_task_order/acknowledge_moves_and_shipments_urlbuilder.go @@ -0,0 +1,87 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package move_task_order + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the generate command + +import ( + "errors" + "net/url" + golangswaggerpaths "path" +) + +// AcknowledgeMovesAndShipmentsURL generates an URL for the acknowledge moves and shipments operation +type AcknowledgeMovesAndShipmentsURL struct { + _basePath string +} + +// WithBasePath sets the base path for this url builder, only required when it's different from the +// base path specified in the swagger spec. +// When the value of the base path is an empty string +func (o *AcknowledgeMovesAndShipmentsURL) WithBasePath(bp string) *AcknowledgeMovesAndShipmentsURL { + o.SetBasePath(bp) + return o +} + +// SetBasePath sets the base path for this url builder, only required when it's different from the +// base path specified in the swagger spec. +// When the value of the base path is an empty string +func (o *AcknowledgeMovesAndShipmentsURL) SetBasePath(bp string) { + o._basePath = bp +} + +// Build a url path and query string +func (o *AcknowledgeMovesAndShipmentsURL) Build() (*url.URL, error) { + var _result url.URL + + var _path = "/move-task-orders/acknowledge" + + _basePath := o._basePath + if _basePath == "" { + _basePath = "/prime/v1" + } + _result.Path = golangswaggerpaths.Join(_basePath, _path) + + return &_result, nil +} + +// Must is a helper function to panic when the url builder returns an error +func (o *AcknowledgeMovesAndShipmentsURL) Must(u *url.URL, err error) *url.URL { + if err != nil { + panic(err) + } + if u == nil { + panic("url can't be nil") + } + return u +} + +// String returns the string representation of the path with query string +func (o *AcknowledgeMovesAndShipmentsURL) String() string { + return o.Must(o.Build()).String() +} + +// BuildFull builds a full url with scheme, host, path and query string +func (o *AcknowledgeMovesAndShipmentsURL) BuildFull(scheme, host string) (*url.URL, error) { + if scheme == "" { + return nil, errors.New("scheme is required for a full url on AcknowledgeMovesAndShipmentsURL") + } + if host == "" { + return nil, errors.New("host is required for a full url on AcknowledgeMovesAndShipmentsURL") + } + + base, err := o.Build() + if err != nil { + return nil, err + } + + base.Scheme = scheme + base.Host = host + return base, nil +} + +// StringFull returns the string representation of a complete url +func (o *AcknowledgeMovesAndShipmentsURL) StringFull(scheme, host string) string { + return o.Must(o.BuildFull(scheme, host)).String() +} diff --git a/pkg/gen/primeapi/primeoperations/mymove_api.go b/pkg/gen/primeapi/primeoperations/mymove_api.go index 6ded41a6c0d..d698f217e1c 100644 --- a/pkg/gen/primeapi/primeoperations/mymove_api.go +++ b/pkg/gen/primeapi/primeoperations/mymove_api.go @@ -50,6 +50,9 @@ func NewMymoveAPI(spec *loads.Document) *MymoveAPI { BinProducer: runtime.ByteStreamProducer(), JSONProducer: runtime.JSONProducer(), + MoveTaskOrderAcknowledgeMovesAndShipmentsHandler: move_task_order.AcknowledgeMovesAndShipmentsHandlerFunc(func(params move_task_order.AcknowledgeMovesAndShipmentsParams) middleware.Responder { + return middleware.NotImplemented("operation move_task_order.AcknowledgeMovesAndShipments has not yet been implemented") + }), MoveTaskOrderCreateExcessWeightRecordHandler: move_task_order.CreateExcessWeightRecordHandlerFunc(func(params move_task_order.CreateExcessWeightRecordParams) middleware.Responder { return middleware.NotImplemented("operation move_task_order.CreateExcessWeightRecord has not yet been implemented") }), @@ -161,6 +164,8 @@ type MymoveAPI struct { // - application/json JSONProducer runtime.Producer + // MoveTaskOrderAcknowledgeMovesAndShipmentsHandler sets the operation handler for the acknowledge moves and shipments operation + MoveTaskOrderAcknowledgeMovesAndShipmentsHandler move_task_order.AcknowledgeMovesAndShipmentsHandler // MoveTaskOrderCreateExcessWeightRecordHandler sets the operation handler for the create excess weight record operation MoveTaskOrderCreateExcessWeightRecordHandler move_task_order.CreateExcessWeightRecordHandler // MtoShipmentCreateMTOAgentHandler sets the operation handler for the create m t o agent operation @@ -286,6 +291,9 @@ func (o *MymoveAPI) Validate() error { unregistered = append(unregistered, "JSONProducer") } + if o.MoveTaskOrderAcknowledgeMovesAndShipmentsHandler == nil { + unregistered = append(unregistered, "move_task_order.AcknowledgeMovesAndShipmentsHandler") + } if o.MoveTaskOrderCreateExcessWeightRecordHandler == nil { unregistered = append(unregistered, "move_task_order.CreateExcessWeightRecordHandler") } @@ -441,6 +449,10 @@ func (o *MymoveAPI) initHandlerCache() { o.handlers = make(map[string]map[string]http.Handler) } + if o.handlers["PATCH"] == nil { + o.handlers["PATCH"] = make(map[string]http.Handler) + } + o.handlers["PATCH"]["/move-task-orders/acknowledge"] = move_task_order.NewAcknowledgeMovesAndShipments(o.context, o.MoveTaskOrderAcknowledgeMovesAndShipmentsHandler) if o.handlers["POST"] == nil { o.handlers["POST"] = make(map[string]http.Handler) } diff --git a/pkg/gen/primeclient/move_task_order/acknowledge_moves_and_shipments_parameters.go b/pkg/gen/primeclient/move_task_order/acknowledge_moves_and_shipments_parameters.go new file mode 100644 index 00000000000..9598961475d --- /dev/null +++ b/pkg/gen/primeclient/move_task_order/acknowledge_moves_and_shipments_parameters.go @@ -0,0 +1,150 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package move_task_order + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + + "github.com/transcom/mymove/pkg/gen/primemessages" +) + +// NewAcknowledgeMovesAndShipmentsParams creates a new AcknowledgeMovesAndShipmentsParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewAcknowledgeMovesAndShipmentsParams() *AcknowledgeMovesAndShipmentsParams { + return &AcknowledgeMovesAndShipmentsParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewAcknowledgeMovesAndShipmentsParamsWithTimeout creates a new AcknowledgeMovesAndShipmentsParams object +// with the ability to set a timeout on a request. +func NewAcknowledgeMovesAndShipmentsParamsWithTimeout(timeout time.Duration) *AcknowledgeMovesAndShipmentsParams { + return &AcknowledgeMovesAndShipmentsParams{ + timeout: timeout, + } +} + +// NewAcknowledgeMovesAndShipmentsParamsWithContext creates a new AcknowledgeMovesAndShipmentsParams object +// with the ability to set a context for a request. +func NewAcknowledgeMovesAndShipmentsParamsWithContext(ctx context.Context) *AcknowledgeMovesAndShipmentsParams { + return &AcknowledgeMovesAndShipmentsParams{ + Context: ctx, + } +} + +// NewAcknowledgeMovesAndShipmentsParamsWithHTTPClient creates a new AcknowledgeMovesAndShipmentsParams object +// with the ability to set a custom HTTPClient for a request. +func NewAcknowledgeMovesAndShipmentsParamsWithHTTPClient(client *http.Client) *AcknowledgeMovesAndShipmentsParams { + return &AcknowledgeMovesAndShipmentsParams{ + HTTPClient: client, + } +} + +/* +AcknowledgeMovesAndShipmentsParams contains all the parameters to send to the API endpoint + + for the acknowledge moves and shipments operation. + + Typically these are written to a http.Request. +*/ +type AcknowledgeMovesAndShipmentsParams struct { + + // Body. + Body primemessages.AcknowledgeMoves + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the acknowledge moves and shipments params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *AcknowledgeMovesAndShipmentsParams) WithDefaults() *AcknowledgeMovesAndShipmentsParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the acknowledge moves and shipments params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *AcknowledgeMovesAndShipmentsParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the acknowledge moves and shipments params +func (o *AcknowledgeMovesAndShipmentsParams) WithTimeout(timeout time.Duration) *AcknowledgeMovesAndShipmentsParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the acknowledge moves and shipments params +func (o *AcknowledgeMovesAndShipmentsParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the acknowledge moves and shipments params +func (o *AcknowledgeMovesAndShipmentsParams) WithContext(ctx context.Context) *AcknowledgeMovesAndShipmentsParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the acknowledge moves and shipments params +func (o *AcknowledgeMovesAndShipmentsParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the acknowledge moves and shipments params +func (o *AcknowledgeMovesAndShipmentsParams) WithHTTPClient(client *http.Client) *AcknowledgeMovesAndShipmentsParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the acknowledge moves and shipments params +func (o *AcknowledgeMovesAndShipmentsParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithBody adds the body to the acknowledge moves and shipments params +func (o *AcknowledgeMovesAndShipmentsParams) WithBody(body primemessages.AcknowledgeMoves) *AcknowledgeMovesAndShipmentsParams { + o.SetBody(body) + return o +} + +// SetBody adds the body to the acknowledge moves and shipments params +func (o *AcknowledgeMovesAndShipmentsParams) SetBody(body primemessages.AcknowledgeMoves) { + o.Body = body +} + +// WriteToRequest writes these params to a swagger request +func (o *AcknowledgeMovesAndShipmentsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + if o.Body != nil { + if err := r.SetBodyParam(o.Body); err != nil { + return err + } + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/pkg/gen/primeclient/move_task_order/acknowledge_moves_and_shipments_responses.go b/pkg/gen/primeclient/move_task_order/acknowledge_moves_and_shipments_responses.go new file mode 100644 index 00000000000..64963740ca7 --- /dev/null +++ b/pkg/gen/primeclient/move_task_order/acknowledge_moves_and_shipments_responses.go @@ -0,0 +1,251 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package move_task_order + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + "github.com/transcom/mymove/pkg/gen/primemessages" +) + +// AcknowledgeMovesAndShipmentsReader is a Reader for the AcknowledgeMovesAndShipments structure. +type AcknowledgeMovesAndShipmentsReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *AcknowledgeMovesAndShipmentsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewAcknowledgeMovesAndShipmentsOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + case 422: + result := NewAcknowledgeMovesAndShipmentsUnprocessableEntity() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 500: + result := NewAcknowledgeMovesAndShipmentsInternalServerError() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + default: + return nil, runtime.NewAPIError("[PATCH /move-task-orders/acknowledge] acknowledgeMovesAndShipments", response, response.Code()) + } +} + +// NewAcknowledgeMovesAndShipmentsOK creates a AcknowledgeMovesAndShipmentsOK with default headers values +func NewAcknowledgeMovesAndShipmentsOK() *AcknowledgeMovesAndShipmentsOK { + return &AcknowledgeMovesAndShipmentsOK{} +} + +/* +AcknowledgeMovesAndShipmentsOK describes a response with status code 200, with default header values. + +Successfully updated Move and Shipment Acknowledgements. +*/ +type AcknowledgeMovesAndShipmentsOK struct { + Payload *primemessages.AcknowledgeMovesShipmentsSuccessResponse +} + +// IsSuccess returns true when this acknowledge moves and shipments o k response has a 2xx status code +func (o *AcknowledgeMovesAndShipmentsOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this acknowledge moves and shipments o k response has a 3xx status code +func (o *AcknowledgeMovesAndShipmentsOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this acknowledge moves and shipments o k response has a 4xx status code +func (o *AcknowledgeMovesAndShipmentsOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this acknowledge moves and shipments o k response has a 5xx status code +func (o *AcknowledgeMovesAndShipmentsOK) IsServerError() bool { + return false +} + +// IsCode returns true when this acknowledge moves and shipments o k response a status code equal to that given +func (o *AcknowledgeMovesAndShipmentsOK) IsCode(code int) bool { + return code == 200 +} + +// Code gets the status code for the acknowledge moves and shipments o k response +func (o *AcknowledgeMovesAndShipmentsOK) Code() int { + return 200 +} + +func (o *AcknowledgeMovesAndShipmentsOK) Error() string { + return fmt.Sprintf("[PATCH /move-task-orders/acknowledge][%d] acknowledgeMovesAndShipmentsOK %+v", 200, o.Payload) +} + +func (o *AcknowledgeMovesAndShipmentsOK) String() string { + return fmt.Sprintf("[PATCH /move-task-orders/acknowledge][%d] acknowledgeMovesAndShipmentsOK %+v", 200, o.Payload) +} + +func (o *AcknowledgeMovesAndShipmentsOK) GetPayload() *primemessages.AcknowledgeMovesShipmentsSuccessResponse { + return o.Payload +} + +func (o *AcknowledgeMovesAndShipmentsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(primemessages.AcknowledgeMovesShipmentsSuccessResponse) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewAcknowledgeMovesAndShipmentsUnprocessableEntity creates a AcknowledgeMovesAndShipmentsUnprocessableEntity with default headers values +func NewAcknowledgeMovesAndShipmentsUnprocessableEntity() *AcknowledgeMovesAndShipmentsUnprocessableEntity { + return &AcknowledgeMovesAndShipmentsUnprocessableEntity{} +} + +/* +AcknowledgeMovesAndShipmentsUnprocessableEntity describes a response with status code 422, with default header values. + +The request was unprocessable, likely due to bad input from the requester. +*/ +type AcknowledgeMovesAndShipmentsUnprocessableEntity struct { + Payload *primemessages.ValidationError +} + +// IsSuccess returns true when this acknowledge moves and shipments unprocessable entity response has a 2xx status code +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this acknowledge moves and shipments unprocessable entity response has a 3xx status code +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) IsRedirect() bool { + return false +} + +// IsClientError returns true when this acknowledge moves and shipments unprocessable entity response has a 4xx status code +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) IsClientError() bool { + return true +} + +// IsServerError returns true when this acknowledge moves and shipments unprocessable entity response has a 5xx status code +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) IsServerError() bool { + return false +} + +// IsCode returns true when this acknowledge moves and shipments unprocessable entity response a status code equal to that given +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) IsCode(code int) bool { + return code == 422 +} + +// Code gets the status code for the acknowledge moves and shipments unprocessable entity response +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) Code() int { + return 422 +} + +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) Error() string { + return fmt.Sprintf("[PATCH /move-task-orders/acknowledge][%d] acknowledgeMovesAndShipmentsUnprocessableEntity %+v", 422, o.Payload) +} + +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) String() string { + return fmt.Sprintf("[PATCH /move-task-orders/acknowledge][%d] acknowledgeMovesAndShipmentsUnprocessableEntity %+v", 422, o.Payload) +} + +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) GetPayload() *primemessages.ValidationError { + return o.Payload +} + +func (o *AcknowledgeMovesAndShipmentsUnprocessableEntity) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(primemessages.ValidationError) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} + +// NewAcknowledgeMovesAndShipmentsInternalServerError creates a AcknowledgeMovesAndShipmentsInternalServerError with default headers values +func NewAcknowledgeMovesAndShipmentsInternalServerError() *AcknowledgeMovesAndShipmentsInternalServerError { + return &AcknowledgeMovesAndShipmentsInternalServerError{} +} + +/* +AcknowledgeMovesAndShipmentsInternalServerError describes a response with status code 500, with default header values. + +A server error occurred. +*/ +type AcknowledgeMovesAndShipmentsInternalServerError struct { + Payload *primemessages.Error +} + +// IsSuccess returns true when this acknowledge moves and shipments internal server error response has a 2xx status code +func (o *AcknowledgeMovesAndShipmentsInternalServerError) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this acknowledge moves and shipments internal server error response has a 3xx status code +func (o *AcknowledgeMovesAndShipmentsInternalServerError) IsRedirect() bool { + return false +} + +// IsClientError returns true when this acknowledge moves and shipments internal server error response has a 4xx status code +func (o *AcknowledgeMovesAndShipmentsInternalServerError) IsClientError() bool { + return false +} + +// IsServerError returns true when this acknowledge moves and shipments internal server error response has a 5xx status code +func (o *AcknowledgeMovesAndShipmentsInternalServerError) IsServerError() bool { + return true +} + +// IsCode returns true when this acknowledge moves and shipments internal server error response a status code equal to that given +func (o *AcknowledgeMovesAndShipmentsInternalServerError) IsCode(code int) bool { + return code == 500 +} + +// Code gets the status code for the acknowledge moves and shipments internal server error response +func (o *AcknowledgeMovesAndShipmentsInternalServerError) Code() int { + return 500 +} + +func (o *AcknowledgeMovesAndShipmentsInternalServerError) Error() string { + return fmt.Sprintf("[PATCH /move-task-orders/acknowledge][%d] acknowledgeMovesAndShipmentsInternalServerError %+v", 500, o.Payload) +} + +func (o *AcknowledgeMovesAndShipmentsInternalServerError) String() string { + return fmt.Sprintf("[PATCH /move-task-orders/acknowledge][%d] acknowledgeMovesAndShipmentsInternalServerError %+v", 500, o.Payload) +} + +func (o *AcknowledgeMovesAndShipmentsInternalServerError) GetPayload() *primemessages.Error { + return o.Payload +} + +func (o *AcknowledgeMovesAndShipmentsInternalServerError) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + o.Payload = new(primemessages.Error) + + // response payload + if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/pkg/gen/primeclient/move_task_order/move_task_order_client.go b/pkg/gen/primeclient/move_task_order/move_task_order_client.go index b1d0d6c8a1b..b406fb3cf3d 100644 --- a/pkg/gen/primeclient/move_task_order/move_task_order_client.go +++ b/pkg/gen/primeclient/move_task_order/move_task_order_client.go @@ -31,6 +31,8 @@ type ClientOption func(*runtime.ClientOperation) // ClientService is the interface for Client methods type ClientService interface { + AcknowledgeMovesAndShipments(params *AcknowledgeMovesAndShipmentsParams, opts ...ClientOption) (*AcknowledgeMovesAndShipmentsOK, error) + CreateExcessWeightRecord(params *CreateExcessWeightRecordParams, opts ...ClientOption) (*CreateExcessWeightRecordCreated, error) DownloadMoveOrder(params *DownloadMoveOrderParams, writer io.Writer, opts ...ClientOption) (*DownloadMoveOrderOK, error) @@ -44,6 +46,49 @@ type ClientService interface { SetTransport(transport runtime.ClientTransport) } +/* + AcknowledgeMovesAndShipments acknowledges moves and shipments + + ### Functionality + +This endpoint **updates** the Moves and Shipments to indicate that the Prime has acknowledged the Moves and Shipments have been received. +The Move and Shipment data is expected to be sent in the request body. +*/ +func (a *Client) AcknowledgeMovesAndShipments(params *AcknowledgeMovesAndShipmentsParams, opts ...ClientOption) (*AcknowledgeMovesAndShipmentsOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewAcknowledgeMovesAndShipmentsParams() + } + op := &runtime.ClientOperation{ + ID: "acknowledgeMovesAndShipments", + Method: "PATCH", + PathPattern: "/move-task-orders/acknowledge", + ProducesMediaTypes: []string{"application/json"}, + ConsumesMediaTypes: []string{"application/json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &AcknowledgeMovesAndShipmentsReader{formats: a.formats}, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*AcknowledgeMovesAndShipmentsOK) + if ok { + return success, nil + } + // unexpected success response + // safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue + msg := fmt.Sprintf("unexpected success response for acknowledgeMovesAndShipments: API contract not enforced by server. Client expected to get an error, but got: %T", result) + panic(msg) +} + /* CreateExcessWeightRecord creates excess weight record diff --git a/pkg/gen/primemessages/acknowledge_move.go b/pkg/gen/primemessages/acknowledge_move.go new file mode 100644 index 00000000000..7ba67ab3d49 --- /dev/null +++ b/pkg/gen/primemessages/acknowledge_move.go @@ -0,0 +1,164 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package primemessages + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// AcknowledgeMove acknowledge move +// +// swagger:model AcknowledgeMove +type AcknowledgeMove struct { + + // id + // Example: a502b4f1-b9c4-4faf-8bdd-68292501bf26 + // Format: uuid + ID strfmt.UUID `json:"id,omitempty"` + + // mto shipments + MtoShipments []*AcknowledgeShipment `json:"mtoShipments"` + + // prime acknowledged at + // Example: 2025-04-13T14:15:22Z + // Format: date-time + PrimeAcknowledgedAt strfmt.DateTime `json:"primeAcknowledgedAt,omitempty"` +} + +// Validate validates this acknowledge move +func (m *AcknowledgeMove) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + res = append(res, err) + } + + if err := m.validateMtoShipments(formats); err != nil { + res = append(res, err) + } + + if err := m.validatePrimeAcknowledgedAt(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AcknowledgeMove) validateID(formats strfmt.Registry) error { + if swag.IsZero(m.ID) { // not required + return nil + } + + if err := validate.FormatOf("id", "body", "uuid", m.ID.String(), formats); err != nil { + return err + } + + return nil +} + +func (m *AcknowledgeMove) validateMtoShipments(formats strfmt.Registry) error { + if swag.IsZero(m.MtoShipments) { // not required + return nil + } + + for i := 0; i < len(m.MtoShipments); i++ { + if swag.IsZero(m.MtoShipments[i]) { // not required + continue + } + + if m.MtoShipments[i] != nil { + if err := m.MtoShipments[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("mtoShipments" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("mtoShipments" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +func (m *AcknowledgeMove) validatePrimeAcknowledgedAt(formats strfmt.Registry) error { + if swag.IsZero(m.PrimeAcknowledgedAt) { // not required + return nil + } + + if err := validate.FormatOf("primeAcknowledgedAt", "body", "date-time", m.PrimeAcknowledgedAt.String(), formats); err != nil { + return err + } + + return nil +} + +// ContextValidate validate this acknowledge move based on the context it is used +func (m *AcknowledgeMove) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + if err := m.contextValidateMtoShipments(ctx, formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AcknowledgeMove) contextValidateMtoShipments(ctx context.Context, formats strfmt.Registry) error { + + for i := 0; i < len(m.MtoShipments); i++ { + + if m.MtoShipments[i] != nil { + + if swag.IsZero(m.MtoShipments[i]) { // not required + return nil + } + + if err := m.MtoShipments[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("mtoShipments" + "." + strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName("mtoShipments" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +// MarshalBinary interface implementation +func (m *AcknowledgeMove) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AcknowledgeMove) UnmarshalBinary(b []byte) error { + var res AcknowledgeMove + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/gen/primemessages/acknowledge_moves.go b/pkg/gen/primemessages/acknowledge_moves.go new file mode 100644 index 00000000000..f3d6c9e8a15 --- /dev/null +++ b/pkg/gen/primemessages/acknowledge_moves.go @@ -0,0 +1,78 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package primemessages + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "strconv" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// AcknowledgeMoves acknowledge moves +// +// swagger:model AcknowledgeMoves +type AcknowledgeMoves []*AcknowledgeMove + +// Validate validates this acknowledge moves +func (m AcknowledgeMoves) Validate(formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + if swag.IsZero(m[i]) { // not required + continue + } + + if m[i] != nil { + if err := m[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// ContextValidate validate this acknowledge moves based on the context it is used +func (m AcknowledgeMoves) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + var res []error + + for i := 0; i < len(m); i++ { + + if m[i] != nil { + + if swag.IsZero(m[i]) { // not required + return nil + } + + if err := m[i].ContextValidate(ctx, formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName(strconv.Itoa(i)) + } else if ce, ok := err.(*errors.CompositeError); ok { + return ce.ValidateName(strconv.Itoa(i)) + } + return err + } + } + + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/pkg/gen/primemessages/acknowledge_moves_shipments_success_response.go b/pkg/gen/primemessages/acknowledge_moves_shipments_success_response.go new file mode 100644 index 00000000000..5cec37a6c30 --- /dev/null +++ b/pkg/gen/primemessages/acknowledge_moves_shipments_success_response.go @@ -0,0 +1,51 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package primemessages + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// AcknowledgeMovesShipmentsSuccessResponse acknowledge moves shipments success response +// +// swagger:model AcknowledgeMovesShipmentsSuccessResponse +type AcknowledgeMovesShipmentsSuccessResponse struct { + + // message + // Example: Moves/Shipments acknowledgement successfully completed + Message string `json:"message,omitempty"` +} + +// Validate validates this acknowledge moves shipments success response +func (m *AcknowledgeMovesShipmentsSuccessResponse) Validate(formats strfmt.Registry) error { + return nil +} + +// ContextValidate validates this acknowledge moves shipments success response based on context it is used +func (m *AcknowledgeMovesShipmentsSuccessResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *AcknowledgeMovesShipmentsSuccessResponse) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AcknowledgeMovesShipmentsSuccessResponse) UnmarshalBinary(b []byte) error { + var res AcknowledgeMovesShipmentsSuccessResponse + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/gen/primemessages/acknowledge_shipment.go b/pkg/gen/primemessages/acknowledge_shipment.go new file mode 100644 index 00000000000..bf47553d3bb --- /dev/null +++ b/pkg/gen/primemessages/acknowledge_shipment.go @@ -0,0 +1,96 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package primemessages + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/errors" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// AcknowledgeShipment acknowledge shipment +// +// swagger:model AcknowledgeShipment +type AcknowledgeShipment struct { + + // id + // Example: 1f2270c7-7166-40ae-981e-b200ebdf3054 + // Format: uuid + ID strfmt.UUID `json:"id,omitempty"` + + // prime acknowledged at + // Example: 2025-04-13T14:15:33Z + // Format: date-time + PrimeAcknowledgedAt strfmt.DateTime `json:"primeAcknowledgedAt,omitempty"` +} + +// Validate validates this acknowledge shipment +func (m *AcknowledgeShipment) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + res = append(res, err) + } + + if err := m.validatePrimeAcknowledgedAt(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AcknowledgeShipment) validateID(formats strfmt.Registry) error { + if swag.IsZero(m.ID) { // not required + return nil + } + + if err := validate.FormatOf("id", "body", "uuid", m.ID.String(), formats); err != nil { + return err + } + + return nil +} + +func (m *AcknowledgeShipment) validatePrimeAcknowledgedAt(formats strfmt.Registry) error { + if swag.IsZero(m.PrimeAcknowledgedAt) { // not required + return nil + } + + if err := validate.FormatOf("primeAcknowledgedAt", "body", "date-time", m.PrimeAcknowledgedAt.String(), formats); err != nil { + return err + } + + return nil +} + +// ContextValidate validates this acknowledge shipment based on context it is used +func (m *AcknowledgeShipment) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *AcknowledgeShipment) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AcknowledgeShipment) UnmarshalBinary(b []byte) error { + var res AcknowledgeShipment + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/pkg/handlers/primeapi/api.go b/pkg/handlers/primeapi/api.go index 49af19e2cf9..697336ca029 100644 --- a/pkg/handlers/primeapi/api.go +++ b/pkg/handlers/primeapi/api.go @@ -10,6 +10,7 @@ import ( "github.com/transcom/mymove/pkg/handlers" paperwork "github.com/transcom/mymove/pkg/paperwork" paymentrequesthelper "github.com/transcom/mymove/pkg/payment_request" + acknowledgemovesshipments "github.com/transcom/mymove/pkg/services/acknowledge_moves_shipments" "github.com/transcom/mymove/pkg/services/address" "github.com/transcom/mymove/pkg/services/entitlements" "github.com/transcom/mymove/pkg/services/fetch" @@ -203,5 +204,10 @@ func NewPrimeAPI(handlerConfig handlers.HandlerConfig) *primeoperations.MymoveAP primeDownloadMoveUploadPDFGenerator, } + primeAPI.MoveTaskOrderAcknowledgeMovesAndShipmentsHandler = AcknowledgeMovesAndShipmentsHandler{ + handlerConfig, + acknowledgemovesshipments.NewMoveAndShipmentAcknowledgementUpdater(), + } + return primeAPI } diff --git a/pkg/handlers/primeapi/move_task_order.go b/pkg/handlers/primeapi/move_task_order.go index 96d03dbf4c8..b83a35cb4fd 100644 --- a/pkg/handlers/primeapi/move_task_order.go +++ b/pkg/handlers/primeapi/move_task_order.go @@ -19,6 +19,8 @@ import ( "github.com/transcom/mymove/pkg/models" "github.com/transcom/mymove/pkg/notifications" "github.com/transcom/mymove/pkg/services" + + "github.com/transcom/mymove/pkg/gen/primemessages" ) // ListMovesHandler lists moves with the option to filter since a particular date. Optimized ver. @@ -379,3 +381,39 @@ func (h DownloadMoveOrderHandler) Handle(params movetaskorderops.DownloadMoveOrd return movetaskorderops.NewDownloadMoveOrderOK().WithContentDisposition(contentDisposition).WithPayload(payload), nil }) } + +type AcknowledgeMovesAndShipmentsHandler struct { + handlers.HandlerConfig + services.MoveAndShipmentAcknowledgementUpdater +} + +func (h AcknowledgeMovesAndShipmentsHandler) Handle(params movetaskorderops.AcknowledgeMovesAndShipmentsParams) middleware.Responder { + return h.AuditableAppContextFromRequestWithErrors(params.HTTPRequest, + func(appCtx appcontext.AppContext) (middleware.Responder, error) { + + payload := params.Body + + if payload == nil { + invalidMovesError := apperror.NewBadDataError("Invalid moves: params Body is nil") + appCtx.Logger().Error(invalidMovesError.Error()) + return movetaskorderops.NewAcknowledgeMovesAndShipmentsUnprocessableEntity(), invalidMovesError + } + moves, verrs := payloads.MovesModelFromAcknowledgeMovesAndShipments(&payload) + if verrs != nil && verrs.HasAny() { + return movetaskorderops.NewAcknowledgeMovesAndShipmentsUnprocessableEntity().WithPayload(payloads.ValidationError( + "Invalid input found in moves", h.GetTraceIDFromRequest(params.HTTPRequest), verrs)), verrs + } else if moves == nil { + return movetaskorderops.NewAcknowledgeMovesAndShipmentsUnprocessableEntity().WithPayload( + payloads.ValidationError("Unable to process moves", h.GetTraceIDFromRequest(params.HTTPRequest), nil)), verrs + } + // Call service to acknowledge moves/shipments here + err := h.MoveAndShipmentAcknowledgementUpdater.AcknowledgeMovesAndShipments(appCtx, moves) + if err != nil { + return movetaskorderops.NewAcknowledgeMovesAndShipmentsInternalServerError(), err + } + responsePayload := &primemessages.AcknowledgeMovesShipmentsSuccessResponse{ + Message: "Successfully updated acknowledgement for moves and shipments", + } + return movetaskorderops.NewAcknowledgeMovesAndShipmentsOK().WithPayload(responsePayload), nil + }) +} diff --git a/pkg/handlers/primeapi/move_task_order_test.go b/pkg/handlers/primeapi/move_task_order_test.go index a25a898c963..6ca663dce4a 100644 --- a/pkg/handlers/primeapi/move_task_order_test.go +++ b/pkg/handlers/primeapi/move_task_order_test.go @@ -2554,3 +2554,111 @@ func (suite *HandlerSuite) TestDownloadMoveOrderHandler() { suite.Assertions.IsType(&movetaskorderops.DownloadMoveOrderInternalServerError{}, downloadMoveOrderResponse) }) } + +func (suite *HandlerSuite) TestAcknowledgeMovesAndShipmentsHandler() { + suite.Run("Successful Acknowledge Moves and Shipments - 200", func() { + mockMoveAndShipmentAcknowledgementUpdater := mocks.MoveAndShipmentAcknowledgementUpdater{} + move := factory.BuildMoveWithShipment(suite.DB(), nil, nil) + handlerConfig := suite.HandlerConfig() + handler := AcknowledgeMovesAndShipmentsHandler{ + HandlerConfig: handlerConfig, + MoveAndShipmentAcknowledgementUpdater: &mockMoveAndShipmentAcknowledgementUpdater, + } + + mockMoveAndShipmentAcknowledgementUpdater.On("AcknowledgeMovesAndShipments", + mock.AnythingOfType("*appcontext.appContext"), + mock.AnythingOfType("*models.Moves"), + ).Return(nil) + + requestUser := factory.BuildUser(nil, nil, nil) + request := httptest.NewRequest("PATCH", "/move-task-orders/acknowledge", nil) + + acknowledgeShipment := primemessages.AcknowledgeShipment{ + ID: strfmt.UUID(move.MTOShipments[0].ID.String()), + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -1)), + } + + payload := primemessages.AcknowledgeMoves{ + &primemessages.AcknowledgeMove{ + ID: strfmt.UUID(move.ID.String()), + MtoShipments: []*primemessages.AcknowledgeShipment{ + &acknowledgeShipment, + }, + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -2)), + }, + } + request = suite.AuthenticateUserRequest(request, requestUser) + params := movetaskorderops.AcknowledgeMovesAndShipmentsParams{ + HTTPRequest: request, + Body: payload, + } + response := handler.Handle(params) + handlerResponse := response.(*movetaskorderops.AcknowledgeMovesAndShipmentsOK) + suite.Assertions.IsType(&movetaskorderops.AcknowledgeMovesAndShipmentsOK{}, handlerResponse) + suite.Equal("Successfully updated acknowledgement for moves and shipments", handlerResponse.Payload.Message) + }) + + suite.Run("Unsuccessful Acknowledge Moves and Shipments - 500", func() { + mockMoveAndShipmentAcknowledgementUpdater := mocks.MoveAndShipmentAcknowledgementUpdater{} + move := factory.BuildMoveWithShipment(suite.DB(), nil, nil) + handlerConfig := suite.HandlerConfig() + handler := AcknowledgeMovesAndShipmentsHandler{ + HandlerConfig: handlerConfig, + MoveAndShipmentAcknowledgementUpdater: &mockMoveAndShipmentAcknowledgementUpdater, + } + + mockError := errors.New("error executing prime_acknowledge_moves_shipments procedure") + mockMoveAndShipmentAcknowledgementUpdater.On("AcknowledgeMovesAndShipments", + mock.AnythingOfType("*appcontext.appContext"), + mock.AnythingOfType("*models.Moves"), + ).Return(mockError) + + requestUser := factory.BuildUser(nil, nil, nil) + request := httptest.NewRequest("PATCH", "/move-task-orders/acknowledge", nil) + + acknowledgeShipment := primemessages.AcknowledgeShipment{ + ID: strfmt.UUID(move.MTOShipments[0].ID.String()), + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -1)), + } + + payload := primemessages.AcknowledgeMoves{ + &primemessages.AcknowledgeMove{ + ID: strfmt.UUID(move.ID.String()), + MtoShipments: []*primemessages.AcknowledgeShipment{ + &acknowledgeShipment, + }, + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -2)), + }, + } + request = suite.AuthenticateUserRequest(request, requestUser) + params := movetaskorderops.AcknowledgeMovesAndShipmentsParams{ + HTTPRequest: request, + Body: payload, + } + response := handler.Handle(params) + handlerResponse := response.(*movetaskorderops.AcknowledgeMovesAndShipmentsInternalServerError) + suite.Assertions.IsType(&movetaskorderops.AcknowledgeMovesAndShipmentsInternalServerError{}, handlerResponse) + }) + + suite.Run("Unsuccessful Acknowledge Moves and Shipments - 422", func() { + mockMoveAndShipmentAcknowledgementUpdater := mocks.MoveAndShipmentAcknowledgementUpdater{} + handlerConfig := suite.HandlerConfig() + handler := AcknowledgeMovesAndShipmentsHandler{ + HandlerConfig: handlerConfig, + MoveAndShipmentAcknowledgementUpdater: &mockMoveAndShipmentAcknowledgementUpdater, + } + + requestUser := factory.BuildUser(nil, nil, nil) + request := httptest.NewRequest("PATCH", "/move-task-orders/acknowledge", nil) + + payload := primemessages.AcknowledgeMoves{} + request = suite.AuthenticateUserRequest(request, requestUser) + params := movetaskorderops.AcknowledgeMovesAndShipmentsParams{ + HTTPRequest: request, + Body: payload, + } + response := handler.Handle(params) + handlerResponse := response.(*movetaskorderops.AcknowledgeMovesAndShipmentsUnprocessableEntity) + suite.Assertions.IsType(&movetaskorderops.AcknowledgeMovesAndShipmentsUnprocessableEntity{}, handlerResponse) + }) +} diff --git a/pkg/handlers/primeapi/payloads/payload_to_model.go b/pkg/handlers/primeapi/payloads/payload_to_model.go index c01b4913c18..a771b21e007 100644 --- a/pkg/handlers/primeapi/payloads/payload_to_model.go +++ b/pkg/handlers/primeapi/payloads/payload_to_model.go @@ -1067,3 +1067,38 @@ func validateReasonInternationalOriginSIT(m primemessages.MTOServiceItemInternat } return verrs } + +func MovesModelFromAcknowledgeMovesAndShipments(acknowledgeMoves *primemessages.AcknowledgeMoves) (*models.Moves, *validate.Errors) { + verrs := validate.NewErrors() + if acknowledgeMoves == nil || len(*acknowledgeMoves) == 0 { + verrs.Add("acknowledgeMoves", "value cannot be nil or empty") + return nil, verrs + } + var moves = models.Moves{} + for _, movePayload := range *acknowledgeMoves { + if movePayload.ID.String() == "" { + verrs.Add("AcknowledgeMove.ID", "value cannot be empty") + return nil, verrs + } + move := models.Move{ + ID: uuid.FromStringOrNil(movePayload.ID.String()), + PrimeAcknowledgedAt: (*time.Time)(&movePayload.PrimeAcknowledgedAt), + } + if movePayload.MtoShipments != nil { + for _, mtoShipmentPayload := range movePayload.MtoShipments { + if mtoShipmentPayload.ID.String() == "" { + verrs.Add("AcknowledgeShipment.ID", "value cannot be empty") + return nil, verrs + } + mtoShipment := models.MTOShipment{ + ID: uuid.FromStringOrNil(mtoShipmentPayload.ID.String()), + PrimeAcknowledgedAt: (*time.Time)(&mtoShipmentPayload.PrimeAcknowledgedAt), + } + move.MTOShipments = append(move.MTOShipments, mtoShipment) + } + } + moves = append(moves, move) + } + + return &moves, nil +} diff --git a/pkg/handlers/primeapi/payloads/payload_to_model_test.go b/pkg/handlers/primeapi/payloads/payload_to_model_test.go index 667bad2439f..3e458fc1dfc 100644 --- a/pkg/handlers/primeapi/payloads/payload_to_model_test.go +++ b/pkg/handlers/primeapi/payloads/payload_to_model_test.go @@ -7,6 +7,7 @@ import ( "github.com/go-openapi/strfmt" "github.com/gofrs/uuid" + "github.com/transcom/mymove/pkg/factory" "github.com/transcom/mymove/pkg/gen/primemessages" "github.com/transcom/mymove/pkg/handlers" "github.com/transcom/mymove/pkg/models" @@ -975,3 +976,147 @@ func (suite *PayloadsSuite) TestVLocationModel() { suite.Equal(postalCode, payload.UsprZipID, "Expected PostalCode to match") suite.Equal(county, payload.UsprcCountyNm, "Expected County to match") } + +func (suite *PayloadsSuite) TestAcknowledgeMovesAndShipmentsToMovesModel() { + var emptyString string + order := factory.BuildOrder(suite.DB(), nil, nil) + move1 := factory.BuildMove(suite.DB(), []factory.Customization{ + { + Model: models.Move{ + Status: models.MoveStatusAPPROVED, + }, + }, + { + Model: order, + LinkOnly: true, + }, + }, nil) + shipment1 := factory.BuildMTOShipmentMinimal(suite.DB(), []factory.Customization{ + { + Model: move1, + LinkOnly: true, + }, + }, nil) + shipment2 := factory.BuildMTOShipmentMinimal(suite.DB(), []factory.Customization{ + { + Model: move1, + LinkOnly: true, + }, + }, nil) + move2 := factory.BuildMove(suite.DB(), []factory.Customization{ + { + Model: models.Move{ + Status: models.MoveStatusAPPROVED, + }, + }, + }, nil) + shipment3 := factory.BuildMTOShipmentMinimal(suite.DB(), []factory.Customization{ + { + Model: move2, + LinkOnly: true, + }, + }, nil) + + suite.Run("Success - Converts Prime Acknowledge Moves Payload to Moves", func() { + acknowledgeShipment1 := primemessages.AcknowledgeShipment{ + ID: strfmt.UUID(shipment1.ID.String()), + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -1)), + } + acknowledgeShipment2 := primemessages.AcknowledgeShipment{ + ID: strfmt.UUID(shipment2.ID.String()), + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -2)), + } + acknowledgeMove1 := primemessages.AcknowledgeMove{ + ID: strfmt.UUID(move1.ID.String()), + MtoShipments: []*primemessages.AcknowledgeShipment{ + &acknowledgeShipment1, + &acknowledgeShipment2, + }, + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -1)), + } + acknowledgeShipment3 := primemessages.AcknowledgeShipment{ + ID: strfmt.UUID(shipment3.ID.String()), + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -3)), + } + acknowledgeMove2 := primemessages.AcknowledgeMove{ + ID: strfmt.UUID(move2.ID.String()), + MtoShipments: []*primemessages.AcknowledgeShipment{ + &acknowledgeShipment3, + }, + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -3)), + } + acknowledgeMovesAndShipments := primemessages.AcknowledgeMoves{ + &acknowledgeMove1, + &acknowledgeMove2, + } + result, verrs := MovesModelFromAcknowledgeMovesAndShipments(&acknowledgeMovesAndShipments) + + suite.NoVerrs(verrs) + suite.NotNil(result) + + var moves = *result + suite.Equal(len(moves), 2) + + //First move + suite.Equal(moves[0].ID.String(), acknowledgeMove1.ID.String()) + suite.Equal(*moves[0].PrimeAcknowledgedAt, time.Time(acknowledgeMove1.PrimeAcknowledgedAt)) + suite.Equal(len(moves[0].MTOShipments), len(acknowledgeMove1.MtoShipments)) + + //First shipment in first move + suite.Equal(moves[0].MTOShipments[0].ID.String(), acknowledgeMove1.MtoShipments[0].ID.String()) + suite.Equal(*moves[0].MTOShipments[0].PrimeAcknowledgedAt, time.Time(acknowledgeMove1.MtoShipments[0].PrimeAcknowledgedAt)) + + //Second shipment in the first move + suite.Equal(moves[0].MTOShipments[1].ID.String(), acknowledgeMove1.MtoShipments[1].ID.String()) + suite.Equal(*moves[0].MTOShipments[1].PrimeAcknowledgedAt, time.Time(acknowledgeMove1.MtoShipments[1].PrimeAcknowledgedAt)) + + // Second move + suite.Equal(moves[1].ID.String(), acknowledgeMove2.ID.String()) + suite.Equal(*moves[1].PrimeAcknowledgedAt, time.Time(acknowledgeMove2.PrimeAcknowledgedAt)) + suite.Equal(len(moves[1].MTOShipments), len(acknowledgeMove2.MtoShipments)) + + //First shipment in the second move + suite.Equal(moves[1].MTOShipments[0].ID.String(), acknowledgeMove2.MtoShipments[0].ID.String()) + suite.Equal(*moves[1].MTOShipments[0].PrimeAcknowledgedAt, time.Time(acknowledgeMove2.MtoShipments[0].PrimeAcknowledgedAt)) + + }) + suite.Run("Unsuccessful - Errors when passed an invalid uuid for a Move", func() { + acknowledgeShipment1 := primemessages.AcknowledgeShipment{ + ID: strfmt.UUID(shipment1.ID.String()), + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -1)), + } + acknowledgeMove1 := primemessages.AcknowledgeMove{ + ID: strfmt.UUID(emptyString), + MtoShipments: []*primemessages.AcknowledgeShipment{ + &acknowledgeShipment1, + }, + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -1)), + } + acknowledgeMovesAndShipments := primemessages.AcknowledgeMoves{ + &acknowledgeMove1, + } + result, verrs := MovesModelFromAcknowledgeMovesAndShipments(&acknowledgeMovesAndShipments) + suite.Nil(result) + suite.True(verrs.HasAny()) + }) + + suite.Run("Unsuccessful - Errors when passed an invalid uuid for a Shipment", func() { + acknowledgeShipment1 := primemessages.AcknowledgeShipment{ + ID: strfmt.UUID(emptyString), + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -1)), + } + acknowledgeMove1 := primemessages.AcknowledgeMove{ + ID: strfmt.UUID(move1.ID.String()), + MtoShipments: []*primemessages.AcknowledgeShipment{ + &acknowledgeShipment1, + }, + PrimeAcknowledgedAt: strfmt.DateTime(time.Now().AddDate(0, 0, -1)), + } + acknowledgeMovesAndShipments := primemessages.AcknowledgeMoves{ + &acknowledgeMove1, + } + result, verrs := MovesModelFromAcknowledgeMovesAndShipments(&acknowledgeMovesAndShipments) + suite.Nil(result) + suite.True(verrs.HasAny()) + }) +} diff --git a/pkg/services/acknowledge_moves_shipments.go b/pkg/services/acknowledge_moves_shipments.go new file mode 100644 index 00000000000..26c20297be2 --- /dev/null +++ b/pkg/services/acknowledge_moves_shipments.go @@ -0,0 +1,11 @@ +package services + +import ( + "github.com/transcom/mymove/pkg/appcontext" + "github.com/transcom/mymove/pkg/models" +) + +//go:generate mockery --name MoveAndShipmentAcknowledgementUpdater +type MoveAndShipmentAcknowledgementUpdater interface { + AcknowledgeMovesAndShipments(appCtx appcontext.AppContext, moves *models.Moves) error +} diff --git a/pkg/services/acknowledge_moves_shipments/acknowledge_moves_shipments_service_test.go b/pkg/services/acknowledge_moves_shipments/acknowledge_moves_shipments_service_test.go new file mode 100644 index 00000000000..d59e45deb48 --- /dev/null +++ b/pkg/services/acknowledge_moves_shipments/acknowledge_moves_shipments_service_test.go @@ -0,0 +1,26 @@ +package acknowledgemovesshipments + +import ( + "testing" + + "github.com/spf13/afero" + "github.com/stretchr/testify/suite" + + "github.com/transcom/mymove/pkg/testingsuite" +) + +type AcknowledgeMovesAndShipmentsServiceSuite struct { + *testingsuite.PopTestSuite + fs *afero.Afero +} + +func TestAcknowledgeMovesAndShipmentsServiceSuite(t *testing.T) { + var f = afero.NewMemMapFs() + file := &afero.Afero{Fs: f} + ts := &AcknowledgeMovesAndShipmentsServiceSuite{ + PopTestSuite: testingsuite.NewPopTestSuite(testingsuite.CurrentPackage(), testingsuite.WithPerTestTransaction()), + fs: file, + } + suite.Run(t, ts) + ts.PopTestSuite.TearDown() +} diff --git a/pkg/services/acknowledge_moves_shipments/move_shipment_acknowledgement_updater.go b/pkg/services/acknowledge_moves_shipments/move_shipment_acknowledgement_updater.go new file mode 100644 index 00000000000..fa65c4e6502 --- /dev/null +++ b/pkg/services/acknowledge_moves_shipments/move_shipment_acknowledgement_updater.go @@ -0,0 +1,104 @@ +package acknowledgemovesshipments + +import ( + "encoding/json" + "fmt" + "time" + + "github.com/gofrs/uuid" + "github.com/transcom/mymove/pkg/appcontext" + "github.com/transcom/mymove/pkg/models" + "github.com/transcom/mymove/pkg/services" +) + +type moveAndShipmentAcknowledgementUpdater struct { +} + +// NewMoveAndShipmentAcknowledgementUpdater returns a new moveAndShipmentAcknowledgementUpdater +func NewMoveAndShipmentAcknowledgementUpdater() services.MoveAndShipmentAcknowledgementUpdater { + return &moveAndShipmentAcknowledgementUpdater{} +} + +func (p *moveAndShipmentAcknowledgementUpdater) AcknowledgeMovesAndShipments(appCtx appcontext.AppContext, moves *models.Moves) error { + + // Convert to JSON so we can pass it to the DB procedure + jsonData, err := customMarshalJSON(*moves) + if err != nil { + return fmt.Errorf("error converting moves to json for prime_acknowledge_moves_shipments procedure: %w", err) + } + + // Call procedure to update move and shipment acknowledgement dates + err = appCtx.DB().RawQuery("CALL prime_acknowledge_moves_shipments($1)", string(jsonData)).Exec() + if err != nil { + return fmt.Errorf("error executing prime_acknowledge_moves_shipments procedure: %w", err) + } + return nil +} + +func customMarshalJSON(v interface{}) ([]byte, error) { + switch obj := v.(type) { + case models.Move: + return marshalMove(obj) + case models.Moves: + return marshalMoves(obj) + case models.MTOShipment: + return marshalMTOShipment(obj) + case models.MTOShipments: + return marshalMTOShipments(obj) + default: + return nil, fmt.Errorf("unsupported type for custom JSON marshaling") + } +} + +// Only marshaling ID, MTOShipments, and Prime AcknowledgedAt fields +func marshalMove(m models.Move) ([]byte, error) { + marshaledShipments, err := marshalMTOShipments(m.MTOShipments) + if err != nil { + return nil, fmt.Errorf("error marshaling MTOShipments: %w", err) + } + + return json.Marshal(struct { + ID uuid.UUID `json:"id"` + MTOShipments json.RawMessage `json:"mtoShipments"` + PrimeAcknowledgedAt *time.Time `json:"primeAcknowledgedAt"` + }{ + ID: m.ID, + MTOShipments: marshaledShipments, + PrimeAcknowledgedAt: m.PrimeAcknowledgedAt, + }) +} + +func marshalMoves(moves models.Moves) ([]byte, error) { + customMoves := make([]json.RawMessage, len(moves)) + for i, move := range moves { + marshaledMove, err := marshalMove(move) + if err != nil { + return nil, err + } + customMoves[i] = marshaledMove + } + return json.Marshal(customMoves) +} + +// Only marshaling ID, and Prime AcknowledgedAt fields +func marshalMTOShipment(s models.MTOShipment) ([]byte, error) { + return json.Marshal(struct { + ID uuid.UUID `json:"id"` + PrimeAcknowledgedAt *time.Time `json:"primeAcknowledgedAt"` + }{ + ID: s.ID, + PrimeAcknowledgedAt: s.PrimeAcknowledgedAt, + }) +} + +func marshalMTOShipments(shipments models.MTOShipments) ([]byte, error) { + customShipments := make([]json.RawMessage, len(shipments)) + for i, shipment := range shipments { + marshaledShipment, err := marshalMTOShipment(shipment) + if err != nil { + return nil, err + } + customShipments[i] = marshaledShipment + } + return json.Marshal(customShipments) +} diff --git a/pkg/services/acknowledge_moves_shipments/move_shipment_acknowledgement_updater_test.go b/pkg/services/acknowledge_moves_shipments/move_shipment_acknowledgement_updater_test.go new file mode 100644 index 00000000000..b755e579616 --- /dev/null +++ b/pkg/services/acknowledge_moves_shipments/move_shipment_acknowledgement_updater_test.go @@ -0,0 +1,126 @@ +package acknowledgemovesshipments + +import ( + "time" + + "github.com/transcom/mymove/pkg/factory" + "github.com/transcom/mymove/pkg/models" +) + +func (suite *AcknowledgeMovesAndShipmentsServiceSuite) TestUpdateMoveAcknowledgement() { + moveAndShipmentAcknowledgementUpdater := NewMoveAndShipmentAcknowledgementUpdater() + + suite.Run("Move and Shipment acknowledgement dates are updated successfully", func() { + + var threeDaysAgo = time.Now().AddDate(0, 0, -3) + var twoDaysAgo = time.Now().AddDate(0, 0, -2) + var yesterday = time.Now().AddDate(0, 0, -1) + move1 := factory.BuildMoveWithShipment(suite.DB(), nil, nil) + move2 := factory.BuildMoveWithShipment(suite.DB(), nil, nil) + + // Add an additional shipment to move 2 + factory.BuildMTOShipmentMinimal(suite.DB(), []factory.Customization{ + { + Model: move2, + LinkOnly: true, + }, + }, nil) + move1.PrimeAcknowledgedAt = &threeDaysAgo + move1.MTOShipments[0].PrimeAcknowledgedAt = &twoDaysAgo + + // grab move 2 from the db to pull in the 2nd shipment + move2 = models.Move{ + ID: move2.ID, + } + suite.DB().EagerPreload("MTOShipments").Find(&move2, move2.ID) + move2.PrimeAcknowledgedAt = &threeDaysAgo + move2.MTOShipments[0].PrimeAcknowledgedAt = &twoDaysAgo + move2.MTOShipments[1].PrimeAcknowledgedAt = &yesterday + moves := models.Moves{ + move1, + move2, + } + err := moveAndShipmentAcknowledgementUpdater.AcknowledgeMovesAndShipments(suite.AppContextForTest(), &moves) + suite.NoError(err) + + dbMove1 := models.Move{} + + // Validate move 1 + err = suite.DB().EagerPreload("MTOShipments").Find(&dbMove1, move1.ID) + suite.NoError(err) + suite.Equal(move1.ID, dbMove1.ID) + suite.Equal(move1.PrimeAcknowledgedAt.UTC(), dbMove1.PrimeAcknowledgedAt.UTC()) + // Move 1 shipment 1 + suite.Equal(move1.MTOShipments[0].ID, dbMove1.MTOShipments[0].ID) + suite.Equal(move1.MTOShipments[0].PrimeAcknowledgedAt.UTC(), dbMove1.MTOShipments[0].PrimeAcknowledgedAt.UTC()) + + dbMove2 := models.Move{} + // Validate move 2 + err = suite.DB().EagerPreload("MTOShipments").Find(&dbMove2, move2.ID) + suite.NoError(err) + suite.Equal(move2.ID, dbMove2.ID) + suite.Equal(move2.PrimeAcknowledgedAt.UTC(), dbMove2.PrimeAcknowledgedAt.UTC()) + // Move 2 shipment 1 + suite.Equal(move2.MTOShipments[0].ID, dbMove2.MTOShipments[0].ID) + suite.Equal(move2.MTOShipments[0].PrimeAcknowledgedAt.UTC(), dbMove2.MTOShipments[0].PrimeAcknowledgedAt.UTC()) + // Move 2 shipment 2 + suite.Equal(move2.MTOShipments[1].ID, dbMove2.MTOShipments[1].ID) + suite.Equal(move2.MTOShipments[1].PrimeAcknowledgedAt.UTC(), dbMove2.MTOShipments[1].PrimeAcknowledgedAt.UTC()) + }) + + suite.Run("Move and Shipment acknowledgement date are not updated when they are not provided", func() { + + move := factory.BuildMoveWithShipment(suite.DB(), nil, nil) + moves := models.Moves{ + move, + } + err := moveAndShipmentAcknowledgementUpdater.AcknowledgeMovesAndShipments(suite.AppContextForTest(), &moves) + suite.NoError(err) + + dbMove := models.Move{} + err = suite.DB().EagerPreload("MTOShipments").Find(&dbMove, move.ID) + suite.NoError(err) + suite.Equal(move.ID, dbMove.ID) + suite.Nil(dbMove.PrimeAcknowledgedAt) + suite.Equal(move.MTOShipments[0].ID, dbMove.MTOShipments[0].ID) + suite.Nil(dbMove.MTOShipments[0].PrimeAcknowledgedAt) + }) + + suite.Run("Move and Shipment acknowledgement dates are NOT updated if they are already populated in the DB", func() { + + var fourDaysAgo = time.Now().AddDate(0, 0, -4) + var threeDaysAgo = time.Now().AddDate(0, 0, -3) + var twoDaysAgo = time.Now().AddDate(0, 0, -2) + move := factory.BuildMoveWithShipment(suite.DB(), []factory.Customization{ + { + Model: models.Move{ + PrimeAcknowledgedAt: &fourDaysAgo, + }, + }, + { + Model: models.MTOShipment{ + PrimeAcknowledgedAt: &fourDaysAgo, + }, + }, + }, nil) + + //Attempting to update prime acknowledged at dates that are already popualted in the DB. + move.PrimeAcknowledgedAt = &threeDaysAgo + move.MTOShipments[0].PrimeAcknowledgedAt = &twoDaysAgo + moves := models.Moves{ + move, + } + err := moveAndShipmentAcknowledgementUpdater.AcknowledgeMovesAndShipments(suite.AppContextForTest(), &moves) + suite.NoError(err) + + dbMove := models.Move{} + err = suite.DB().EagerPreload("MTOShipments").Find(&dbMove, move.ID) + suite.NoError(err) + suite.Equal(move.ID, dbMove.ID) + suite.NotEqual(move.PrimeAcknowledgedAt.UTC(), dbMove.PrimeAcknowledgedAt.UTC(), "Prime acknowledged at date was not updated") + suite.Equal(fourDaysAgo.UTC(), dbMove.PrimeAcknowledgedAt.UTC(), "Prime acknowledged at date remained 4 days ago") + suite.Equal(move.MTOShipments[0].ID, dbMove.MTOShipments[0].ID) + suite.NotEqual(move.MTOShipments[0].PrimeAcknowledgedAt.UTC(), dbMove.MTOShipments[0].PrimeAcknowledgedAt.UTC(), "Prime acknowledged at date was not updated") + suite.Equal(fourDaysAgo.UTC(), dbMove.PrimeAcknowledgedAt.UTC(), "Prime acknowledged at date remained 4 days ago") + }) +} diff --git a/pkg/services/mocks/MoveAndShipmentAcknowledgementUpdater.go b/pkg/services/mocks/MoveAndShipmentAcknowledgementUpdater.go new file mode 100644 index 00000000000..56c438316b3 --- /dev/null +++ b/pkg/services/mocks/MoveAndShipmentAcknowledgementUpdater.go @@ -0,0 +1,47 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + appcontext "github.com/transcom/mymove/pkg/appcontext" + + models "github.com/transcom/mymove/pkg/models" +) + +// MoveAndShipmentAcknowledgementUpdater is an autogenerated mock type for the MoveAndShipmentAcknowledgementUpdater type +type MoveAndShipmentAcknowledgementUpdater struct { + mock.Mock +} + +// AcknowledgeMovesAndShipments provides a mock function with given fields: appCtx, moves +func (_m *MoveAndShipmentAcknowledgementUpdater) AcknowledgeMovesAndShipments(appCtx appcontext.AppContext, moves *models.Moves) error { + ret := _m.Called(appCtx, moves) + + if len(ret) == 0 { + panic("no return value specified for AcknowledgeMovesAndShipments") + } + + var r0 error + if rf, ok := ret.Get(0).(func(appcontext.AppContext, *models.Moves) error); ok { + r0 = rf(appCtx, moves) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// NewMoveAndShipmentAcknowledgementUpdater creates a new instance of MoveAndShipmentAcknowledgementUpdater. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMoveAndShipmentAcknowledgementUpdater(t interface { + mock.TestingT + Cleanup(func()) +}) *MoveAndShipmentAcknowledgementUpdater { + mock := &MoveAndShipmentAcknowledgementUpdater{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/pkg/services/mto_service_item/mto_service_item_validators_test.go b/pkg/services/mto_service_item/mto_service_item_validators_test.go index 4b74be7b68f..581e8f68e23 100644 --- a/pkg/services/mto_service_item/mto_service_item_validators_test.go +++ b/pkg/services/mto_service_item/mto_service_item_validators_test.go @@ -1215,7 +1215,6 @@ func (suite *MTOServiceItemServiceSuite) TestUpdateMTOServiceItemData() { suite.Contains(serviceItemData.verrs.Keys(), "SITDepartureDate") suite.Contains(serviceItemData.verrs.Get("SITDepartureDate"), "SIT departure date cannot be set before or equal to the SIT entry date.") } - }) suite.Run("SITDepartureDate - errors when set before the SIT entry date - international", func() { diff --git a/swagger-def/definitions/prime/AcknowledgeMove.yaml b/swagger-def/definitions/prime/AcknowledgeMove.yaml new file mode 100644 index 00000000000..7f4e8896a21 --- /dev/null +++ b/swagger-def/definitions/prime/AcknowledgeMove.yaml @@ -0,0 +1,14 @@ +type: object +properties: + id: + type: string + format: uuid + example: a502b4f1-b9c4-4faf-8bdd-68292501bf26 + primeAcknowledgedAt: + type: string + format: date-time + example: 2025-04-13T14:15:22Z + mtoShipments: + type: array + items: + $ref: 'AcknowledgeShipment.yaml' diff --git a/swagger-def/definitions/prime/AcknowledgeMoves.yaml b/swagger-def/definitions/prime/AcknowledgeMoves.yaml new file mode 100644 index 00000000000..6b309f83694 --- /dev/null +++ b/swagger-def/definitions/prime/AcknowledgeMoves.yaml @@ -0,0 +1,3 @@ +type: array +items: + $ref: 'AcknowledgeMove.yaml' diff --git a/swagger-def/definitions/prime/AcknowledgeMovesShipmentsSuccessResponse.yaml b/swagger-def/definitions/prime/AcknowledgeMovesShipmentsSuccessResponse.yaml new file mode 100644 index 00000000000..af055ccdf79 --- /dev/null +++ b/swagger-def/definitions/prime/AcknowledgeMovesShipmentsSuccessResponse.yaml @@ -0,0 +1,5 @@ +type: object +properties: + message: + type: string + example: 'Moves/Shipments acknowledgement successfully completed' diff --git a/swagger-def/definitions/prime/AcknowledgeShipment.yaml b/swagger-def/definitions/prime/AcknowledgeShipment.yaml new file mode 100644 index 00000000000..5a21cf7acfd --- /dev/null +++ b/swagger-def/definitions/prime/AcknowledgeShipment.yaml @@ -0,0 +1,10 @@ +type: object +properties: + id: + type: string + format: uuid + example: 1f2270c7-7166-40ae-981e-b200ebdf3054 + primeAcknowledgedAt: + type: string + format: date-time + example: 2025-04-13T14:15:33Z diff --git a/swagger-def/prime.yaml b/swagger-def/prime.yaml index 6bfaed1fa76..70e7181a5b2 100644 --- a/swagger-def/prime.yaml +++ b/swagger-def/prime.yaml @@ -194,6 +194,35 @@ paths: $ref: 'responses/UnprocessableEntity.yaml' '500': $ref: '#/responses/ServerError' + /move-task-orders/acknowledge: + patch: + summary: acknowledgeMovesAndShipments + description: | + ### Functionality + This endpoint **updates** the Moves and Shipments to indicate that the Prime has acknowledged the Moves and Shipments have been received. + The Move and Shipment data is expected to be sent in the request body. + operationId: acknowledgeMovesAndShipments + consumes: + - application/json + produces: + - application/json + parameters: + - in: body + name: body + required: true + schema: + $ref: 'definitions/prime/AcknowledgeMoves.yaml' + tags: + - moveTaskOrder + responses: + '200': + description: Successfully updated Move and Shipment Acknowledgements. + schema: + $ref: 'definitions/prime/AcknowledgeMovesShipmentsSuccessResponse.yaml' + '422': + $ref: 'responses/UnprocessableEntity.yaml' + '500': + $ref: '#/responses/ServerError' /mto-shipments: post: summary: createMTOShipment @@ -1543,15 +1572,15 @@ paths: tags: - addresses parameters: - - in: path - name: search - type: string - required: true + - in: path + name: search + type: string + required: true responses: '200': description: the requested list of city, state, county, and postal code matches schema: - $ref: "#/definitions/VLocations" + $ref: '#/definitions/VLocations' '400': $ref: '#/responses/InvalidRequest' '403': @@ -2377,7 +2406,7 @@ definitions: VLocations: type: array items: - $ref: "definitions/VLocation.yaml" + $ref: 'definitions/VLocation.yaml' responses: InvalidRequest: description: The request payload is invalid. diff --git a/swagger/prime.yaml b/swagger/prime.yaml index 98a9dcc0a98..058012780a6 100644 --- a/swagger/prime.yaml +++ b/swagger/prime.yaml @@ -270,6 +270,38 @@ paths: $ref: '#/responses/UnprocessableEntity' '500': $ref: '#/responses/ServerError' + /move-task-orders/acknowledge: + patch: + summary: acknowledgeMovesAndShipments + description: > + ### Functionality + + This endpoint **updates** the Moves and Shipments to indicate that the + Prime has acknowledged the Moves and Shipments have been received. + + The Move and Shipment data is expected to be sent in the request body. + operationId: acknowledgeMovesAndShipments + consumes: + - application/json + produces: + - application/json + parameters: + - in: body + name: body + required: true + schema: + $ref: '#/definitions/AcknowledgeMoves' + tags: + - moveTaskOrder + responses: + '200': + description: Successfully updated Move and Shipment Acknowledgements. + schema: + $ref: '#/definitions/AcknowledgeMovesShipmentsSuccessResponse' + '422': + $ref: '#/responses/UnprocessableEntity' + '500': + $ref: '#/responses/ServerError' /mto-shipments: post: summary: createMTOShipment @@ -5279,6 +5311,42 @@ definitions: type: string required: - invalidFields + AcknowledgeShipment: + type: object + properties: + id: + type: string + format: uuid + example: 1f2270c7-7166-40ae-981e-b200ebdf3054 + primeAcknowledgedAt: + type: string + format: date-time + example: '2025-04-13T14:15:33Z' + AcknowledgeMove: + type: object + properties: + id: + type: string + format: uuid + example: a502b4f1-b9c4-4faf-8bdd-68292501bf26 + primeAcknowledgedAt: + type: string + format: date-time + example: '2025-04-13T14:15:22Z' + mtoShipments: + type: array + items: + $ref: '#/definitions/AcknowledgeShipment' + AcknowledgeMoves: + type: array + items: + $ref: '#/definitions/AcknowledgeMove' + AcknowledgeMovesShipmentsSuccessResponse: + type: object + properties: + message: + type: string + example: Moves/Shipments acknowledgement successfully completed VLocation: description: A postal code, city, and state lookup type: object