Example #1
0
        public async Task <WorkflowGroupRespObj> Handle(GetWorkflowGroupQuery request, CancellationToken cancellationToken)
        {
            var item = await _repo.GetWorkflowGroupAsync(request.WorkflowGroupId);

            var respItem = new WorkflowGroupObj
            {
                WorkflowGroupId   = item.WorkflowGroupId,
                Active            = item.Active,
                CreatedBy         = item.CreatedBy,
                Deleted           = item.Deleted,
                UpdatedBy         = item.UpdatedBy,
                UpdatedOn         = item.UpdatedOn,
                WorkflowGroupName = item.WorkflowGroupName,
            };



            var respItemList = new List <WorkflowGroupObj>()
            {
                respItem
            };

            return(new WorkflowGroupRespObj
            {
                WorkflowGroups = respItemList,
                Status = new APIResponseStatus
                {
                    IsSuccessful = true,
                    Message = new APIResponseMessage
                    {
                        FriendlyMessage = item != null ? null : "Search Complete! No Record Found"
                    }
                }
            });
        }
        public async Task <FileUploadRespObj> Handle(UploadWorkflowGroupCommand request, CancellationToken cancellationToken)
        {
            try
            {
                var apiResponse = new FileUploadRespObj {
                    Status = new APIResponseStatus {
                        IsSuccessful = false, Message = new APIResponseMessage()
                    }
                };

                var files = _httpContextAccessor.HttpContext.Request.Form.Files;

                var byteList = new List <byte[]>();
                foreach (var fileBit in files)
                {
                    if (fileBit.Length > 0)
                    {
                        using (var ms = new MemoryStream())
                        {
                            await fileBit.CopyToAsync(ms);

                            byteList.Add(ms.ToArray());
                        }
                    }
                }

                var uploadedRecord = new List <WorkflowGroupObj>();
                ExcelPackage.LicenseContext = LicenseContext.NonCommercial;

                if (byteList.Count() > 0)
                {
                    foreach (var byteItem in byteList)
                    {
                        using (MemoryStream stream = new MemoryStream(byteItem))
                            using (ExcelPackage excelPackage = new ExcelPackage(stream))
                            {
                                //Use first sheet by default
                                ExcelWorksheet workSheet    = excelPackage.Workbook.Worksheets[0];
                                int            totalRows    = workSheet.Dimension.Rows;
                                int            totalColumns = workSheet.Dimension.Columns;
                                if (totalColumns != 1)
                                {
                                    apiResponse.Status.Message.FriendlyMessage = $"One (1) Column Expected";
                                    return(apiResponse);
                                }
                                //First row is considered as the header
                                for (int i = 2; i <= totalRows; i++)
                                {
                                    var lkp = new WorkflowGroupObj
                                    {
                                        ExcelLineNumber   = i,
                                        WorkflowGroupName = workSheet.Cells[i, 1]?.Value != null ? workSheet.Cells[i, 1]?.Value.ToString() : string.Empty,
                                    };
                                    uploadedRecord.Add(lkp);
                                }
                            }
                    }
                }

                var _DomainList = await _repo.GetAllWorkflowGroupAsync();

                if (uploadedRecord.Count > 0)
                {
                    foreach (var item in uploadedRecord)
                    {
                        if (string.IsNullOrEmpty(item.WorkflowGroupName))
                        {
                            apiResponse.Status.Message.FriendlyMessage = $"Workflow Group Name can not be empty detected on line {item.ExcelLineNumber}";
                            return(apiResponse);
                        }
                        var currentItem = _DomainList.FirstOrDefault(s => s.WorkflowGroupName.Trim().ToLower() == item.WorkflowGroupName.Trim().ToLower() && s.Deleted == false);

                        if (currentItem != null)
                        {
                            currentItem.WorkflowGroupName = currentItem.WorkflowGroupName;
                            await _repo.AddUpdateWorkflowGroupAsync(currentItem);
                        }
                        else
                        {
                            var newItem = new cor_workflowgroup();
                            newItem.WorkflowGroupName = item.WorkflowGroupName;
                            await _repo.AddUpdateWorkflowGroupAsync(newItem);
                        }
                    }
                }
                apiResponse.Status.IsSuccessful            = true;
                apiResponse.Status.Message.FriendlyMessage = "Successful";
                return(apiResponse);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }