public async Task DontRegister(DontRegister parameters, EmailOrDataboxEnum type)
{
var emlNode = await _alfrescoHttpClient.GetNodeInfo(parameters.NodeId, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Path, ParameterType.QueryString)));
if (parameters.Body.Reason.Length < 4)
{
throw new BadRequestException(ErrorCodes.V_MIN_TEXT);
}
if (parameters.Body.Reason.Length > 30)
{
parameters.Body.Reason = parameters.Body.Reason.Substring(0, 30);
}
var body = new NodeBodyUpdate();
var path = string.Empty;
switch (type)
{
case EmailOrDataboxEnum.Email:
if (emlNode?.Entry?.Path?.Name.StartsWith(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.MailRoomEmail, StringComparison.OrdinalIgnoreCase) == false)
{
throw new BadRequestException("", "Node is not in Mailbox");
}
body = new NodeBodyUpdate
{
Properties = new Dictionary <string, object>
{
{ SpisumNames.Properties.EmailNotRegisteredReason, parameters.Body.Reason }
}
};
path = SpisumNames.Paths.MailRoomEmailNotRegistered;
break;
case EmailOrDataboxEnum.Databox:
if (emlNode?.Entry?.Path?.Name.StartsWith(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.MailRoomDataBox, StringComparison.OrdinalIgnoreCase) == false)
{
throw new BadRequestException("", "Node is not in Databox");
}
body = new NodeBodyUpdate
{
Properties = new Dictionary <string, object>
{
{ SpisumNames.Properties.DataBoxNotRegisteredReason, parameters.Body.Reason }
}
};
path = SpisumNames.Paths.MailRoomDataBoxNotRegistered;
break;
}
await _alfrescoHttpClient.UpdateNode(parameters.NodeId, body);
await _nodesService.MoveChildrenByPath(parameters.NodeId, path);
}
public static NodeBodyUpdate SetPermissionInheritance(this NodeBodyUpdate nodeBodyUpdate, bool isInheritanceEnabled = false)
{
if (nodeBodyUpdate.Permissions == null)
{
nodeBodyUpdate.Permissions = new PermissionsBody();
}
nodeBodyUpdate.Permissions.IsInheritanceEnabled = isInheritanceEnabled;
return(nodeBodyUpdate);
}
public async static Task ActualizarNodo(Nodo nodo)
{
NodeBodyUpdate nodeBodyUpdate = new NodeBodyUpdate(nodo.Name);
Nodo nodoAnterior = await ObtenerNodo(nodo.Id);
if (nodo.NodeType != nodoAnterior.NodeType)
{
nodeBodyUpdate.NodeType = nodo.NodeType;
}
string nodoJson = JsonConvert.SerializeObject(nodeBodyUpdate);
await servicioNodos.ActualizarNodo(nodo.Id, nodoJson);
}
public static NodeBodyUpdate AddProperty(this NodeBodyUpdate nodeBodyUpdate, string key, object value)
{
if (nodeBodyUpdate.Properties == null)
{
nodeBodyUpdate.Properties = new Dictionary <string, object>();
}
nodeBodyUpdate.Properties.As <Dictionary <string, object> >()
.Add(key, value);
return(nodeBodyUpdate);
}
public async static Task <Nodo> ActualizarAspectosNodo(Nodo nodoActualizar)
{
NodeBodyUpdate nodeBodyUpdate = new NodeBodyUpdate(nodoActualizar.Name, null, nodoActualizar.AspectNames);
string nodoBodyUpdateJson = JsonConvert.SerializeObject(nodeBodyUpdate);
string respuestaJson = await servicioNodos.ActualizarNodo(nodoActualizar.Id, nodoBodyUpdateJson);
dynamic respuestaDeserializada = JsonConvert.DeserializeObject(respuestaJson);
string nodoJson = JsonConvert.SerializeObject(respuestaDeserializada.entry);
Nodo nodoListo = JsonConvert.DeserializeObject <Nodo>(nodoJson);
//Añadir Aspectos por defecto (Objetos) del nodo
await AñadirAspectos(respuestaDeserializada.entry.properties, nodoListo);
await AñadirTipoPersonalizado(respuestaDeserializada.entry.properties, nodoListo);
return(nodoListo);
}
public static NodeBodyUpdate RemovePermissions(this NodeBodyUpdate bodyUpdate, string prefix = null, string owner = null)
{
if (prefix != null)
{
foreach (var permission in Enum.GetValues(typeof(GroupPermissionTypes)))
{
bodyUpdate.RemovePermission($"{prefix}_{permission}");
}
}
if (owner != null)
{
bodyUpdate.RemovePermission($"{SpisumNames.Prefixes.UserGroup}{owner}");
}
return(bodyUpdate);
}
public static NodeBodyUpdate AddPermissionsWithoutPostfixes(this NodeBodyUpdate bodyUpdate, string prefix = null, string owner = null)
{
if (prefix != null && prefix != SpisumNames.Groups.SpisumAdmin)
{
bodyUpdate.AddPermission($"{prefix}", $"{GroupPermissionTypes.Coordinator}");
}
if (owner != null && owner != SpisumNames.SystemUsers.Spisum && owner != AlfrescoNames.Aliases.Group)
{
bodyUpdate.AddPermission($"{SpisumNames.Prefixes.UserGroup}{owner}", $"{GroupPermissionTypes.Coordinator}");
}
bodyUpdate.AddPermission(SpisumNames.Groups.SpisumAdmin, AlfrescoNames.Permissions.SiteManager);
bodyUpdate.AddPermission(SpisumNames.Groups.DispatchGroup, AlfrescoNames.Permissions.Consumer);
return(bodyUpdate);
}
public async Task <NodeEntry> UploadNewVersionComponent(string nodeId, string componentId, byte[] component, string componentName, string mimeType)
{
var componentEntryBeforeUpload = await _alfrescoHttpClient.GetNodeInfo(componentId);
string newName = $"{IdGenerator.GenerateId()}{ System.IO.Path.GetExtension(componentName) }";
var body = new NodeBodyUpdate();
if (System.IO.Path.GetExtension(componentEntryBeforeUpload?.Entry?.Name) != System.IO.Path.GetExtension(componentName))
{
try
{
var nameSplit = componentEntryBeforeUpload?.Entry?.Name?.Split(".");
newName = $"{nameSplit[0]}{System.IO.Path.GetExtension(componentName)}";
}
catch
{
newName = $"{IdGenerator.GenerateId()}{ System.IO.Path.GetExtension(componentName) }"; // Default name if chanhing extension fails
}
}
// Name must be included in uploading the content. Otherwise Alfresco will not update content properties
await _alfrescoHttpClient.UploadContent(new FormDataParam(component, newName, "filedata", mimeType), ImmutableList <Parameter> .Empty
.Add(new Parameter("filename", newName, ParameterType.GetOrPost))
.Add(new Parameter("destination", "null", ParameterType.GetOrPost))
.Add(new Parameter("uploaddirectory", "", ParameterType.GetOrPost))
.Add(new Parameter("createdirectory", "true", ParameterType.GetOrPost))
.Add(new Parameter("majorVersion", "true", ParameterType.GetOrPost))
.Add(new Parameter("username", "null", ParameterType.GetOrPost))
.Add(new Parameter("overwrite", "true", ParameterType.GetOrPost))
.Add(new Parameter("thumbnails", "null", ParameterType.GetOrPost))
.Add(new Parameter("updatenameandmimetype", "true", ParameterType.GetOrPost))
.Add(new Parameter("updateNodeRef", $"workspace://SpacesStore/{componentId}", ParameterType.GetOrPost)));
var componentPID = await GenerateComponentPID(nodeId, "/", GeneratePIDComponentType.Component);
await _alfrescoHttpClient.UpdateNode(componentId, body
.AddProperty(SpisumNames.Properties.Pid, componentPID)
.AddProperty(SpisumNames.Properties.FileName, componentName)
);
return(await UpdateMainFileComponentVersionProperties(nodeId, componentId, SpisumNames.VersionOperation.Update));
}
public static NodeBodyUpdate RemovePermission(this NodeBodyUpdate nodeBodyUpdate, string authority)
{
if (nodeBodyUpdate.Permissions == null)
{
nodeBodyUpdate.Permissions = new PermissionsBody();
}
if (nodeBodyUpdate.Permissions.LocallySet == null)
{
nodeBodyUpdate.Permissions.LocallySet = new List <PermissionElement>();
}
if (nodeBodyUpdate.Permissions.LocallySet is List <PermissionElement> permissions)
{
permissions.RemoveAll(x => x.AuthorityId == authority);
}
return(nodeBodyUpdate);
}
public static NodeBodyUpdate AddPermissions(this NodeBodyUpdate bodyUpdate, string prefix = null, string owner = null)
{
if (prefix != null && prefix != SpisumNames.Groups.SpisumAdmin) //(bodyUpdate?.Permissions?.LocallySet?.All(x => !x.AuthorityId.StartsWith(prefix)) ?? true)
{
foreach (var permission in Enum.GetValues(typeof(GroupPermissionTypes)))
{
bodyUpdate.AddPermission($"{prefix}_{permission}", $"{permission}");
}
}
if (owner != null && owner != SpisumNames.SystemUsers.Spisum && owner != AlfrescoNames.Aliases.Group) //(bodyUpdate?.Permissions?.LocallySet?.All(x => x.AuthorityId != $"{SpisumNames.Prefixes.UserGroup}{owner}") ?? true)
{
bodyUpdate.AddPermission($"{SpisumNames.Prefixes.UserGroup}{owner}", $"{GroupPermissionTypes.Coordinator}");
}
bodyUpdate.AddPermission(SpisumNames.Groups.SpisumAdmin, AlfrescoNames.Permissions.SiteManager);
bodyUpdate.AddPermission(SpisumNames.Groups.DispatchGroup, AlfrescoNames.Permissions.Consumer);
return(bodyUpdate);
}
public async static Task <Nodo> ActualizarPropiedadesNodo(Nodo nodoActualizar)
{
FormatearPropiedades(nodoActualizar);
//Nota: nodoType=null porque no se puede actualizar al mismo tipo y aspectNames=null porque no se actualiza aspectos
NodeBodyUpdate nodeBodyUpdate = new NodeBodyUpdate(nodoActualizar.Name, null, null,
(Dictionary <string, string>)nodoActualizar.Properties);
string nodoBodyUpdateJson = JsonConvert.SerializeObject(nodeBodyUpdate);
string respuestaJson = await servicioNodos.ActualizarNodo(nodoActualizar.Id, nodoBodyUpdateJson);
dynamic respuestaDeserializada = JsonConvert.DeserializeObject(respuestaJson);
string nodoJson = JsonConvert.SerializeObject(respuestaDeserializada.entry);
Nodo nodoListo = JsonConvert.DeserializeObject <Nodo>(nodoJson);
AñadirAspectos(respuestaDeserializada.entry.properties, nodoListo);
await AñadirTipoPersonalizado(respuestaDeserializada.entry.properties, nodoListo);
return(nodoListo);
}
public static NodeBodyUpdate AddPermission(
this NodeBodyUpdate nodeBodyUpdate,
string authority,
string name,
PermissionElementAccessStatus permissionStatus = PermissionElementAccessStatus.ALLOWED)
{
if (nodeBodyUpdate.Permissions == null)
{
nodeBodyUpdate.Permissions = new PermissionsBody {
IsInheritanceEnabled = false
}
}
;
if (nodeBodyUpdate.Permissions.LocallySet == null)
{
nodeBodyUpdate.Permissions.LocallySet = new List <PermissionElement>();
}
var locallySet = nodeBodyUpdate.Permissions.LocallySet.ToList();
var existingPermission = locallySet.Find(x => x.AuthorityId == authority && x.Name == name);
if (existingPermission != null)
{
existingPermission.AccessStatus = permissionStatus;
}
else
{
locallySet.Add(new PermissionElement
{
AuthorityId = authority,
Name = name,
AccessStatus = permissionStatus
});
}
nodeBodyUpdate.Permissions.LocallySet = locallySet;
return(nodeBodyUpdate);
}
public async Task Init()
{
string XSDFilePath = Path.Combine(_alfrescoConfig.ConfigurationFiles.FolderName,
_alfrescoConfig.ConfigurationFiles.ContentModels.FolderName,
_alfrescoConfig.ConfigurationFiles.ContentModels.XSDValidationFile);
List <ConfigurationContent> files = (from string file in _alfrescoConfig.ConfigurationFiles.ContentModels.Files select new ConfigurationContent
{
FileName = file,
FilePath = Path.Combine(_alfrescoConfig.ConfigurationFiles.FolderName,
_alfrescoConfig.ConfigurationFiles.ContentModels.FolderName,
file)
}).ToList();
foreach (var file in files)
{
try
{
var validationResult = XMLValidator.ValidateXML("http://www.alfresco.org/model/dictionary/1.0", file.FilePath, XSDFilePath);
if (validationResult.IsOK)
{
// Company Home
var repositoryRootFolder = await _alfrescoHttpClient.GetNodeInfo(AlfrescoNames.Aliases.Root);
var modelsNode = await _alfrescoHttpClient.GetNodeInfo(AlfrescoNames.Aliases.Root, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.RelativePath, $"{DataDictionaryConfiguration.DataDictionary}/{DataDictionaryConfiguration.Models}", ParameterType.QueryString)));
FormDataParam fileParams;
using (var memstream = new MemoryStream())
{
File.OpenRead(file.FilePath).CopyTo(memstream);
fileParams = new FormDataParam(memstream.ToArray(), file.FileName);
};
var createdChild = await _alfrescoHttpClient.CreateNode(modelsNode.Entry.Id, fileParams, ImmutableList <Parameter> .Empty
.Add(new Parameter(HeaderNames.ContentType, "multipart/form-data", ParameterType.HttpHeader))
.Add(new Parameter(AlfrescoNames.Headers.OverWrite, true, ParameterType.GetOrPost)));
var properties = new NodeBodyUpdate
{
Properties = new Dictionary <string, object>
{
{ AlfrescoNames.ContentModel.ModelActive, true }
}
};
await _alfrescoHttpClient.UpdateNode(createdChild.Entry.Id, properties,
ImmutableList <Parameter> .Empty
.Add(new Parameter(HeaderNames.ContentType, MediaTypeNames.Application.Json, ParameterType.HttpHeader)));
}
else
{
Log.Error(validationResult.ErrorMessage);
}
}
catch (Exception e)
{
Log.Error(e, "XML or XML file not found");
}
}
}
private async Task <NodeEntry> CreateArhiveAndMoveAllFiles(NodeUpdate body, string archiveFolder, string nodeType)
{
var copiedNodes = new List <NodeEntry>();
var updatedNodes = new List <NodeEntry>();
var connections = new List <Tuple <string, string> >();
var alfrescoBody = _mapper.Map <NodeBodyUpdate>(body);
var documentInfo = await _alfrescoHttpClient.UpdateNode(body.NodeId, alfrescoBody, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Path, ParameterType.QueryString)));
var parentFolderInfo = await _alfrescoHttpClient.GetNodeInfo(documentInfo.Entry.ParentId);
// create folder in archive because copy folder violation
var copyFolderInfo = await _nodesService.CreateFolder(archiveFolder);
AlfrescoPagingRequest <NodeChildAssociationPagingFixed, List19Fixed, NodeChildAssociationEntry> request;
// copy and remove all associations - Copies .eml/.zfo and all it's children to the archive folder
var entries = (await _alfrescoHttpClient.GetNodeChildren(body.NodeId, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.MaxItems, 1, ParameterType.QueryString))
.Add(new Parameter(AlfrescoNames.Headers.Where, $"(nodeType='{nodeType}')", ParameterType.QueryString))))
?.List?.Entries?.ToList();
if (entries?.Count > 0)
{
var nodeId = entries[0]?.Entry?.Id;
request = new AlfrescoPagingRequest <NodeChildAssociationPagingFixed, List19Fixed, NodeChildAssociationEntry>(
parameters => _alfrescoHttpClient.GetNodeSecondaryChildren(nodeId, parameters)
);
while (await request.Next())
{
var response = request.Response();
if (!(response?.List?.Entries?.Count > 0))
{
break;
}
foreach (var item in response.List.Entries.ToList())
{
await _alfrescoHttpClient.DeleteSecondaryChildren(nodeId, item.Entry.Id);
var copyInfo = await _alfrescoHttpClient.NodeCopy(item.Entry.Id, new NodeBodyCopy
{
TargetParentId = copyFolderInfo.Entry.Id
});
var properties = copyInfo.Entry.Properties.As <JObject>().ToDictionary();
var pid = properties.GetNestedValueOrDefault(SpisumNames.Properties.Pid)?.ToString();
await _alfrescoHttpClient.UpdateNode(copyInfo.Entry.Id, new NodeBodyUpdate()
.AddProperty(SpisumNames.Properties.Pid, null)
.AddProperty(SpisumNames.Properties.PidRef, pid)
.AddProperty(SpisumNames.Properties.Ref, item.Entry.Id));
copiedNodes.Add(copyInfo);
}
}
// Copy .eml / .zfo
var copyEmlZfo = await _alfrescoHttpClient.NodeCopy(nodeId, new NodeBodyCopy
{
TargetParentId = copyFolderInfo.Entry.Id
});
var propertiesEmlZfo = copyEmlZfo.Entry.Properties.As <JObject>().ToDictionary();
var pidEmlZfo = propertiesEmlZfo.GetNestedValueOrDefault(SpisumNames.Properties.Pid)?.ToString();
await _alfrescoHttpClient.UpdateNode(copyEmlZfo?.Entry?.Id, new NodeBodyUpdate()
.AddProperty(SpisumNames.Properties.Pid, null)
.AddProperty(SpisumNames.Properties.PidRef, pidEmlZfo)
.AddProperty(SpisumNames.Properties.Ref, nodeId));
copiedNodes.Add(copyEmlZfo);
}
// Take all files and move them to the new location
// find all children and rename + change node type
request = new AlfrescoPagingRequest <NodeChildAssociationPagingFixed, List19Fixed, NodeChildAssociationEntry>(
parameters => _alfrescoHttpClient.GetNodeSecondaryChildren(body.NodeId, parameters)
);
while (await request.Next())
{
var response = request.Response();
if (!(response?.List?.Entries?.Count > 0))
{
break;
}
foreach (var item in response.List.Entries.ToList())
{
if (item.Entry.NodeType == SpisumNames.NodeTypes.Component)
{
continue;
}
connections.Add(new Tuple <string, string>(item.Entry.Id, copiedNodes.FirstOrDefault(x => x.Entry.Name == item.Entry.Name)?.Entry?.Id));
var updateBody = new NodeBodyUpdate();
if (item.Entry.NodeType == AlfrescoNames.ContentModel.Content)
{
updateBody.NodeType = SpisumNames.NodeTypes.Component;
}
if (item.Entry.NodeType == SpisumNames.NodeTypes.Email)
{
updateBody.NodeType = SpisumNames.NodeTypes.EmailComponent;
}
if (item.Entry.NodeType == SpisumNames.NodeTypes.DataBox)
{
updateBody.NodeType = SpisumNames.NodeTypes.DataBoxComponent;
}
var personGroup = await GetCreateUserGroup();
updateBody.Permissions = _nodesService.SetPermissions(personGroup.GroupPrefix, _identityUser.Id).Permissions;
updateBody.Properties = new Dictionary <string, object>
{
{ AlfrescoNames.ContentModel.Owner, _identityUser.Id },
{ SpisumNames.Properties.Group, _identityUser.RequestGroup }
};
updatedNodes.Add(await _alfrescoHttpClient.UpdateNode(item.Entry.Id, updateBody));
if (item.Entry.NodeType == AlfrescoNames.ContentModel.Content)
{
}
}
}
// Set PID to archive
List <NodeEntry> movedNodes = new List <NodeEntry>();
movedNodes.Add(await _nodesService.MoveByPath(body.NodeId, SpisumNames.Paths.EvidenceDocumentsForProcessing(_identityUser.RequestGroup)));
movedNodes.AddRange(await _nodesService.MoveAllComponets(body.NodeId));
foreach (var copy in copiedNodes)
{
var id = connections.First(x => x.Item2 == copy.Entry.Id);
var node = movedNodes.FirstOrDefault(x => x.Entry.Id == id.Item1);
if (node == null)
{
continue;
}
var properties = node.Entry.Properties.As <JObject>().ToDictionary();
var pid = properties.GetNestedValueOrDefault(SpisumNames.Properties.Pid)?.ToString();
if (string.IsNullOrWhiteSpace(pid))
{
continue;
}
await _alfrescoHttpClient.UpdateNode(copy.Entry.Id, new NodeBodyUpdate
{
Properties = new Dictionary <string, object>
{
{ SpisumNames.Properties.PidArchive, pid }
}
});
}
return(await _alfrescoHttpClient.GetNodeInfo(body.NodeId));
}
public static NodeBodyUpdate AddPropertyIfNotNull(this NodeBodyUpdate nodeBodyUpdate, string key, object value)
{
return(value == null ? nodeBodyUpdate : nodeBodyUpdate.AddProperty(key, value));
}
