public async Task <ResponseDTO <ModuleActionsDTO> > GetModuleAsync(GetModuleRequest getRequest)
{
var moduleAux = await SearchModulesAsync(new ModuleSearchRequest { Code = getRequest.Code, Page = 1, PageSize = 1 });
var module = moduleAux.Data.Items.FirstOrDefault();
if (module != null)
{
var actions = await _actionDataAcces.ListAsync(w => w.ModuleCode == module.Code);
var moduleActions = new ModuleActionsDTO
{
Code = module.Code,
Name = module.Name,
Url = module.Url,
SortOrder = module.SortOrder,
ParentModuleCode = module.ParentModuleCode,
Actions = actions.ToList()
};
if (moduleActions.Actions != null)
{
moduleActions.Actions.ForEach(p => p.TableStatus = DTOs.Requests.Common.ObjectStatus.Unchanged);
}
return(ResponseBuilder.Correct(moduleActions));
}
else
{
ModuleActionsDTO obj = null;
return(ResponseBuilder.Correct(obj));
}
}
public IActionResult GetModule(GetModuleRequest input)
{
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace($"{nameof(GetModule)}: {GetModuleRequest.VERB}");
}
if (ModelState.IsValid)
{
_logger.LogDebug($"Module name=[{input.ModuleName}] Version=[{input.ModuleVersion}]");
var moduleContent = _dscHandler.GetModule(input.GetAgentId(),
input.ModuleName, input.ModuleVersion);
if (moduleContent == null)
{
return(NotFound());
}
var response = new GetModuleResponse
{
ChecksumAlgorithmHeader = moduleContent.ChecksumAlgorithm,
ChecksumHeader = moduleContent.Checksum,
Module = moduleContent.Content,
};
return(this.Model(response));
}
return(BadRequest(ModelState));
}
public void GetModuleByID()
{
GetModuleRequest request = new GetModuleRequest {
ModuleID = "5"
};
GetModuleResponse response = ModuleDataManager.GetModuleByID(request);
Assert.IsTrue(response.Module.Id == "Tony");
}
public static GetModuleResponse GetModuleByID(GetModuleRequest request)
{
GetModuleResponse result = new GetModuleResponse();
IModuleRepository <GetModuleResponse> repo = ModuleRepositoryFactory <GetModuleResponse> .GetModuleRepository(request.ContractNumber, request.Context, request.UserId);
var module = repo.FindByID(request.ModuleID);
result.Module = module as DTO.Module;
return(result != null ? result : new GetModuleResponse());
}
private async Task InvalidateModule()
{
var fbb = Debugger.BeginRequest();
int requestDataOffset = GetModuleRequest.CreateGetModuleRequest(fbb, Handle);
var response = await Debugger.CommitRequest(
fbb, RequestData.GetModuleRequest, requestDataOffset);
var responseData = new GetModuleResponse();
response.GetResponseData(responseData);
ModuleType = responseData.Module.Type;
Name = responseData.Module.Name;
Path = responseData.Module.Path;
}
public override Task <GetModuleResponse> GetModule(GetModuleRequest request,
ServerCallContext context)
{
RemoteFrame frame = frameStore.GetObject(request.Frame.Id);
SbModule module = frame.GetModule();
GetModuleResponse response = new GetModuleResponse();
if (module != null)
{
response.Module = new GrpcSbModule {
Id = moduleStore.AddObject(module)
};
}
return(Task.FromResult(response));
}
public GetModuleResponse Get(GetModuleRequest request)
{
GetModuleResponse response = new GetModuleResponse();
try
{
if (string.IsNullOrEmpty(request.UserId))
{
throw new UnauthorizedAccessException("ModuleDD:Get()::Unauthorized Access");
}
response = ModuleDataManager.GetModuleByID(request);
response.Version = request.Version;
}
catch (Exception ex)
{
CommonFormatter.FormatExceptionResponse(response, base.Response, ex);
string aseProcessID = ConfigurationManager.AppSettings.Get("ASEProcessID") ?? "0";
Common.Helper.LogException(int.Parse(aseProcessID), ex);
}
return(response);
}
public GetModuleResponse GetModule(GetModuleRequest request)
{
GetModuleResponse response = new GetModuleResponse();
try
{
Module module = _moduleRepository.FindBy(request.ModuleId);
response.ModuleView = module.ConverToModuleView();
}
catch (Exception ex)
{
string message = "查询失败!错误信息:/n" + ex.Message;
response = new GetModuleResponse()
{
ResponseSucceed = false,
Message = "查询失败"
};
LoggingFactory.GetLogger().WriteDebugLogger(message);
return(response);
}
return(response);
}
// TODO: I think returning a Stream would be better here, but coordinating that
// with the disposable resources that are contained within could be tricky
public async Task <FileResponse> GetModule(string moduleName, string moduleVersion)
{
if (LOG.IsEnabled(LogLevel.Trace))
{
LOG.LogTrace(nameof(GetConfiguration));
}
AssertInit();
var serverConfig = Configuration.ResourceRepositoryServer;
AssertServerConfig(serverConfig);
var dscRequ = new GetModuleRequest
{
AgentId = Configuration.AgentId.ToString(),
ModuleName = moduleName,
ModuleVersion = moduleVersion,
AcceptHeader = DscContentTypes.OCTET_STREAM,
};
var dscResp = new GetModuleResponse();
using (var bs = new MemoryStream())
using (var disposable = await SendDscAsync(serverConfig, GetModuleRequest.VERB,
GetModuleRequest.ROUTE, dscRequ, dscResp))
{
dscResp.Module.CopyTo(bs);
return(new FileResponse
{
ChecksumAlgorithm = dscResp.ChecksumAlgorithmHeader,
Checksum = dscResp.ChecksumHeader,
Content = bs.ToArray(),
});
}
}
public async Task <IActionResult> GetModule(GetModuleRequest input)
{
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace($"{nameof(GetModule)}: {GetModuleRequest.VERB}");
}
if (!ModelState.IsValid)
{
return(base.BadRequest(ModelState));
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"Module name=[{input.ModuleName}] Version=[{input.ModuleVersion}]");
}
var modName = input.ModuleName;
var modVers = input.ModuleVersion;
var modS3Key = $"{_settings.S3KeyPrefixModules}/{modName}/{modVers}.zip";
// We can't simply try to get the S3 object that corresponds to the
// config name being requested because if it doesn't exist, we see
// Amazon.S3.AmazonS3Exception with an underlying message of Access Denied;
// instead we try to list the object first, and if it's not there, we
// can response to the node appropriately with our own error protocol
var listResp = await _s3.ListObjectsV2Async(new ListObjectsV2Request
{
BucketName = _settings.S3Bucket,
Prefix = modS3Key,
MaxKeys = 1,
});
var firstS3Obj = listResp.S3Objects.FirstOrDefault();
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Request to list S3 objects matching requested module found"
+ " [{s3KeyCount}] keys, first is [{s3Key}]", listResp.KeyCount,
firstS3Obj?.Key);
}
if (listResp.KeyCount < 1 || firstS3Obj.Key != modS3Key)
{
_logger.LogWarning($"failed to get module by object key [{modS3Key}]:");
return(NotFound());
}
using (var getResp = await _s3.GetObjectAsync(_settings.S3Bucket, modS3Key))
{
// Because of the preceding ListObjects call,
// this should never happen, but just in case...
if (getResp == null || getResp.ContentLength == 0 ||
getResp.HttpStatusCode != HttpStatusCode.OK)
{
_logger.LogWarning($"failed to get module by object key [{modS3Key}]:"
+ " contentLen=[{getResp?.ContentLength}]"
+ " httpStatus=[{getResp.HttpStatusCode}]");
return(NotFound());
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"got module by object key [{modS3Key}]:"
+ $" contentLen=[{getResp?.ContentLength}]"
+ $" httpStatus=[{getResp.HttpStatusCode}]");
}
using (var rs = getResp.ResponseStream)
{
using (var rawMs = new MemoryStream())
{
await rs.CopyToAsync(rawMs);
// Make sure we're at the start of the stream to compute the checksum
rawMs.Seek(0, SeekOrigin.Begin);
var checksum = ComputeChecksum(rawMs);
// Make sure we're at the start of the stream to return the contents
rawMs.Seek(0, SeekOrigin.Begin);
var rawBytes = rawMs.ToArray();
var b64 = Encoding.UTF8.GetBytes(Convert.ToBase64String(rawBytes));
_logger.LogDebug("Raw bytes length [{rawBytesLen}]", rawBytes.Length);
_logger.LogDebug("B64 bytes length [{b64BytesLen}]", b64.Length);
// This will be disposed of by the MVC framework
var b64Ms = new MemoryStream(b64);
return(this.Model(new GetModuleResponse
{
ChecksumAlgorithmHeader = ChecksumAlgorithm,
ChecksumHeader = checksum,
Module = b64Ms,
}));
}
}
}
}
public async Task <ResponseDTO <ModuleActionsDTO> > Get([FromUri] GetModuleRequest getRequest)
{
var resp = await _modulesApplicationService.GetModuleAsync(new GetModuleRequest { Code = getRequest.Code });
return(resp);
}
