private bool ValidateName(CompoundModel model)
{
this.messageStore.Clear(() => model.Metadata.ObjectName);
var isValid = true;
if (string.IsNullOrEmpty(model.Metadata.ObjectName))
{
this.AddErrorMessage(() => model.Metadata.ObjectName, "Name is required.");
isValid = false;
}
if (model.Metadata.ObjectName.Length > 100)
{
this.AddErrorMessage(() => model.Metadata.ObjectName, "Name is too long (100 character limit).");
isValid = false;
}
var nameRegex = new Regex(@"^[0-9a-zA-Z-]+$");
if (!nameRegex.IsMatch(model.Metadata.ObjectName))
{
this.AddErrorMessage(() => model.Metadata.ObjectName, "Only letters, numbers and hyphens are allowed.");
isValid = false;
}
return(isValid);
}
protected override void ProcessRecord()
{
var input = new CompoundModel()
{
Metadata = new ObjectMetadata()
{
ObjectName = this.Name,
Content = new List <ContentMetadata>(),
ExpirationMetadata = new ExpirationMetadata()
{
ScheduleExpiration = this.ScheduleExpiration,
ExpireAt = this.ExpireAt,
ExpireOnIdleTime = this.ExpireOnIdleTime,
IdleTimeToExpire = this.IdleTimeToExpire
}
},
MainData = Content.ToUnsecureString(),
Permissions = new List <SubjectPermissions>()
};
var attachments = this.CreateAttachmentsList(this.FilesToAttach);
var response = this.apiClient.CreateFromCompoundModelAsync(input, attachments).GetAwaiter().GetResult();
if (!"ok".Equals(response.Status))
{
WriteError(new ErrorRecord(new Exception(response.Error), response.Status, ErrorCategory.NotSpecified, null));
return;
}
WriteObject(new { this.Name, Link = this.CreateSafeSecretLink(this.Name) });
}
private bool ValidateExpirationIdleDays(CompoundModel model)
{
this.messageStore.Clear(() => model.Metadata.ExpirationMetadata.DaysToExpire);
var isValid = true;
if (model.Metadata.ExpirationMetadata.DaysToExpire < 0)
{
this.AddErrorMessage(() => model.Metadata.ExpirationMetadata.DaysToExpire, "Days cannot be negative.");
isValid = false;
}
return(isValid);
}
private void ValidatePermissions(CompoundModel model, bool force = false)
{
var accessList = model.Permissions ?? Array.Empty <SubjectPermissions>().ToList();
foreach (var accessItem in model.Permissions)
{
if (!CurrentEditContext.IsModified(() => accessItem.SubjectName) && !force)
{
continue;
}
if (string.IsNullOrEmpty(accessItem.SubjectName))
{
continue;
}
ValidatePermissionsItem(accessItem);
}
}
private bool ValidateContent(CompoundModel model)
{
this.messageStore.Clear(() => model.MainData);
var isValid = true;
if (string.IsNullOrEmpty(model.MainData))
{
this.AddErrorMessage(() => model.MainData, "Content is required.");
isValid = false;
}
if (model.MainData.Length > 10 * 1024 * 1024)
{
this.AddErrorMessage(() => model.MainData, "Content is too large (10 Mb limit).");
isValid = false;
}
return(isValid);
}
public async Task <BaseResponseObject <CompoundModel> > GetCompoundModelAsync(string secretId)
{
var accessListData = await this.ListAccessAsync(secretId);
if (!"ok".Equals(accessListData.Status))
{
return(new BaseResponseObject <CompoundModel>()
{
Status = accessListData.Status,
Error = accessListData.Error
});
}
var secretMetadata = await this.GetSecretMetadataAsync(secretId);
if (!"ok".Equals(secretMetadata.Status))
{
return(new BaseResponseObject <CompoundModel>()
{
Status = secretMetadata.Status,
Error = secretMetadata.Error
});
}
if (secretMetadata.Result is null)
{
return(new BaseResponseObject <CompoundModel>()
{
Status = "error",
Error = "Received empty metadata reponse."
});
}
StringBuilder?mainDataBuilder = null;
foreach (var secretContent in secretMetadata.Result.Content)
{
if (!secretContent.IsMain)
{
continue; // do not download attachments here
}
var mainDataLength = secretContent.Chunks.Sum(x => (int)x.Length);
mainDataBuilder = new StringBuilder(mainDataLength);
foreach (var chunk in secretContent.Chunks)
{
var dataStream = await this.GetSecretDataStreamAsync(secretId, secretContent.ContentName, chunk.ChunkName);
if (!"ok".Equals(secretMetadata.Status))
{
return(new BaseResponseObject <CompoundModel>()
{
Status = dataStream.Status,
Error = dataStream.Error
});
}
if (dataStream.Result is null)
{
return(new BaseResponseObject <CompoundModel>()
{
Status = "error",
Error = $"Received empty data reponse ('{secretContent.ContentName}'-'{chunk.ChunkName}', {(secretContent.IsMain ? "main content" : "attachment")})."
});
}
string data = string.Empty;
using (var reader = new StreamReader(dataStream.Result))
{
mainDataBuilder.Append(await reader.ReadToEndAsync());
}
}
}
var result = new CompoundModel()
{
Metadata = new ObjectMetadata(secretMetadata.Result),
Permissions = new List <SubjectPermissions>(
accessListData.Result?.Select(p => new SubjectPermissions(p))
?? Array.Empty <SubjectPermissions>()),
MainData = mainDataBuilder?.ToString() ?? "Could not get data."
};
return(new BaseResponseObject <CompoundModel>()
{
Status = "ok",
Result = result
});
}
public async Task <BaseResponseObject <string> > CreateFromCompoundModelAsync(CompoundModel input, List <AttachmentModel> attachments)
{
var secretMetadata = await this.CreateSecretMetadataAsync(input.Metadata.ObjectName, input.Metadata.ToCreationDto());
if (!"ok".Equals(secretMetadata.Status))
{
return(new BaseResponseObject <string>()
{
Status = secretMetadata.Status,
Error = secretMetadata.Error
});
}
if (secretMetadata.Result == null)
{
return(new BaseResponseObject <string>()
{
Status = "error",
Error = "Could not get metadata from response."
});
}
var content = new ContentMetadata(secretMetadata.Result.Content.First(c => c.IsMain));
using (var dataStream = new MemoryStream())
{
using (var writer = new StreamWriter(dataStream, Encoding.UTF8, 4096, leaveOpen: true))
{
await writer.WriteAsync(input.MainData);
await writer.FlushAsync();
dataStream.Position = 0;
}
var secretMainData = await this.PutSecretDataStreamAsync(input.Metadata.ObjectName, content.ContentName, dataStream);
if (!"ok".Equals(secretMainData.Status))
{
return(new BaseResponseObject <string>()
{
Status = secretMainData.Status,
Error = secretMainData.Error
});
}
}
await this.UploadAttachmentsAsync(input.Metadata.ObjectName, attachments);
var permissions = input.Permissions.Where(p => !string.IsNullOrWhiteSpace(p.SubjectName)).ToList();
if (permissions.Count > 0)
{
var accessReply = await this.GrantAccessAsync(
input.Metadata.ObjectName, permissions.Select(p => p.ToDto()).ToList());
if (!"ok".Equals(accessReply.Status))
{
// TODO ...
}
}
return(new BaseResponseObject <string>()
{
Status = "ok",
Result = "ok"
});
}
