Beispiel #1
0
        public async Task <ActionResult> Delete(string id)
        {
            var serviceRequest = await _query.GetAsync(id);

            if (serviceRequest != null)
            {
                try
                {
                    // 1. try to rebuild aggregate
                    ServiceRequestAggregate serviceRequestAggregate = new ServiceRequestAggregate(
                        serviceRequest.Id,
                        serviceRequest.BuildingCode,
                        serviceRequest.Description,
                        serviceRequest.Status,
                        serviceRequest.CreatedBy,
                        serviceRequest.CreatedDate,
                        serviceRequest.LastModifiedBy,
                        serviceRequest.LastUpdatedBy
                        );

                    // 2. Archive this aggregate
                    await _repo.ArchiveAsync(serviceRequestAggregate);

                    return(Created($"api/servicerequest/{serviceRequestAggregate.Id}", serviceRequestAggregate));
                }
                catch (ServiceRequestDomainException ex)
                {
                    return(BadRequest("Invalid request"));
                }
            }
            else
            {
                return(NotFound("Resource Not Found"));
            }
        }
 public Task <string> CreateAsync(ServiceRequestAggregate serviceRequest)
 {
     return(Task.Run(() => {
         _context.ServiceRequests.Add(Map(serviceRequest));
         return serviceRequest.Id;
     }));
 }
 public Task UpdateAsync(ServiceRequestAggregate serviceRequestAggregate)
 {
     return(Task.Run(() => {
         var serviceRequest = GetById(serviceRequestAggregate.Id);
         if (serviceRequest == null)
         {
             throw new Exception("Record Not Found");
         }
         else
         {
             serviceRequest.Status = (int)serviceRequestAggregate.Status;
         }
     }));
 }
 private ServiceRequest Map(ServiceRequestAggregate serviceRequest)
 {
     return(new ServiceRequest()
     {
         Id = serviceRequest.Id,
         BuildingCode = serviceRequest.BuildingCode,
         Description = serviceRequest.Description,
         Status = (int)serviceRequest.Status,
         CreatedBy = serviceRequest.CreatedBy,
         CreatedDate = serviceRequest.CreatedDate,
         LastModifiedBy = serviceRequest.LastModifiedBy,
         LastUpdatedBy = serviceRequest.LastUpdatedBy,
         Active = 1
     });
 }
 public Task <string> ArchiveAsync(ServiceRequestAggregate serviceRequestAggregate)
 {
     return(Task.Run(() => {
         var serviceRequest = GetById(serviceRequestAggregate.Id);
         if (serviceRequest == null)
         {
             throw new Exception("Record Not Found");
         }
         else
         {
             serviceRequest.Active = 0;
         }
         return serviceRequestAggregate.Id;
     }));
 }
Beispiel #6
0
        public async Task <ActionResult> Post([FromBody] CreateServiceRequest req)
        {
            string serviceRequestAggregateId = "";
            ServiceRequestAggregate serviceRequestAggregate;

            try
            {
                // 1. Try to create the aggregate
                string user = ""; // Pull this out of auth or something
                string guid = Guid.NewGuid().ToString();
                serviceRequestAggregate = new ServiceRequestAggregate(
                    guid,
                    req.buildingCode,
                    req.description,
                    (int)ServiceRequestStatus.Created,
                    req.createdBy,
                    DateTime.Now,
                    user,
                    DateTime.Now
                    );

                // 2. Persist aggregate
                serviceRequestAggregateId = await _repo.CreateAsync(serviceRequestAggregate);
            }
            catch (ServiceRequestDomainException ex)
            {
                return(BadRequest(ex.Message));
            }

            try
            {
                // 3. Sideaffects
                SendEmail(serviceRequestAggregate);
            }
            catch (Exception ex)
            {
                // log
            }
            return(Created($"api/servicerequest/{serviceRequestAggregateId}", serviceRequestAggregate));
        }
Beispiel #7
0
        public async Task <ActionResult> Put(string id, [FromBody] UpdateServiceRequest req)
        {
            var serviceRequest = await _query.GetAsync(id);

            if (serviceRequest != null)
            {
                try
                {
                    // 1. try to rebuild aggregate
                    ServiceRequestAggregate serviceRequestAggregate = new ServiceRequestAggregate(
                        serviceRequest.Id,
                        serviceRequest.BuildingCode,
                        serviceRequest.Description,
                        serviceRequest.Status,
                        serviceRequest.CreatedBy,
                        serviceRequest.CreatedDate,
                        serviceRequest.LastModifiedBy,
                        serviceRequest.LastUpdatedBy
                        );

                    // 2. try to update status
                    //  I assumed this was the main thing to update?
                    //  if more needs to be updated the aggregate can be extended with methods to do so
                    serviceRequestAggregate.UpdateStatus(req.status);

                    // 2. persist new aggregate
                    await _repo.UpdateAsync(serviceRequestAggregate);

                    return(Ok(serviceRequestAggregate));
                } catch (ServiceRequestDomainException ex)
                {
                    return(BadRequest(ex.Message));
                }
            }
            else
            {
                return(NotFound("Resource Not Found"));
            }
        }
Beispiel #8
0
 private void SendEmail(ServiceRequestAggregate serviceRequest)
 {
     Console.WriteLine(serviceRequest);
 }