void SendMetadataDto(string fileName, MetadataDTO metadataDTO, MetadataQuorumDto dataservers)
{
int timestamp = dataservers.timestamps[metadataPort - base_port];
MetadataContent metadata = new MetadataContent(metadataDTO, __OPEN__, timestamp);
metadataDB.Add(fileName, metadata);
Console.WriteLine("File \"" + fileName + "\" created by client and replicated to this metadata server.");
}
private static void LoadUpdateQnADTOs(
IEnumerable <PortalDbRecordDTO> portalDbRecords,
QnADocumentsDTO qnaDocumentsDTO,
List <UpdateQnaDTO> updateQnADTOs)
{
foreach (PortalDbRecordDTO portalDbRecord in portalDbRecords)
{
Questions questions = new Questions();
questions.Add = new List <string>();
Metadata metadata = new Metadata();
metadata.Add = new List <MetadataDTO>();
metadata.Delete = new List <MetadataDTO>();
foreach (QnADTO qnAdto in qnaDocumentsDTO.QnaDTO)
{
IEnumerable <string> source = qnAdto.Metadata.Where <MetadataDTO>((Func <MetadataDTO, bool>)(m => m.Name.ToLower() == "faqid")).Select <MetadataDTO, string>((Func <MetadataDTO, string>)(m => m.Value));
if (source.FirstOrDefault <string>() != null)
{
string str = source.FirstOrDefault <string>().ToString();
if (portalDbRecord.FaqId.ToString() == str)
{
questions.Add.Add(portalDbRecord.FaqQuestion);
foreach (MetadataDTO metadataDto1 in qnAdto.Metadata)
{
MetadataDTO metadataDto2 = new MetadataDTO()
{
Name = metadataDto1.Name,
Value = metadataDto1.Value
};
metadata.Delete.Add(metadataDto2);
}
List <MetadataDTO> metadataDtoList = LoadMetadata(portalDbRecord);
foreach (var metadataDto in metadataDtoList)
{
metadata.Add.Add(metadataDto);
}
UpdateQnaDTO updateQnaDto = new UpdateQnaDTO()
{
Answer = portalDbRecord.FaqAnswer,
Context = qnAdto.Context,
Id = qnAdto.Id,
Metadata = metadata,
Questions = questions,
Source = qnAdto.Source
};
updateQnADTOs.Add(updateQnaDto);
}
}
}
}
}
public static IEnumerable <DomainDataDTO> GetMetdataChildren(MetadataDTO editDTO, IEnumerable <DomainDataDTO> currentMetaData)
{
List <DTO.DomainDataDTO> metaData = new List <DTO.DomainDataDTO>();
foreach (var meta in editDTO.ChildMetadata)
{
if (meta.DataType != "reference" && meta.DataType != "boolean")
{
if (meta.Value != null && meta.Value != "")
{
if (currentMetaData.Any(cm => cm.DomainUseID == meta.DomainUseID))
{
metaData.Add(UpdateDomainData(currentMetaData.Where(cm => cm.DomainUseID == meta.DomainUseID).FirstOrDefault(), meta.Value, 0));
}
else
{
metaData.Add(CreateDomainData(meta.DomainUseID.Value, null, meta.Value, 0));
}
}
if (meta.ChildMetadata != null && meta.ChildMetadata.Count() > 0)
{
metaData.AddRange(GetMetdataChildren(meta, currentMetaData));
}
}
else if (meta.DataType == "boolean")
{
if (meta.Value == "true")
{
if (currentMetaData.Any(cm => cm.DomainUseID == meta.DomainUseID))
{
metaData.Add(UpdateDomainData(currentMetaData.Where(cm => cm.DomainUseID == meta.DomainUseID).FirstOrDefault(), null, 0));
}
else
{
metaData.Add(CreateDomainData(meta.DomainUseID.Value, null, null, 0));
}
}
}
else
{
if (meta.References != null && meta.References.Count() > 0)
{
metaData.AddRange(GetReferenceItems(meta, currentMetaData));
}
if (meta.ChildMetadata != null && meta.ChildMetadata.Count() > 0)
{
metaData.AddRange(GetMetdataChildren(meta, currentMetaData));
}
}
}
return(metaData);
}
//Active replication: remove metadata entrance
public void replicateDelete(MetadataDTO metadata)
{
if (ReplicateDeleteHandler != null)
{
ReplicateDeleteHandler(metadata);
}
else
{
throw new System.InvalidOperationException("ReplicateDeleteHandler instance in MetadataMessageService doesn't exists!");
}
}
/* SendMetadataDto: send metadata from criated file from elected metadata server
*/
public void SendMetadataDto(string fileName, MetadataDTO metadataDTO, MetadataQuorumDto dataservers)
{
if (SendMetadataDtoHandler != null)
{
SendMetadataDtoHandler(fileName, metadataDTO, dataservers);
}
else
{
throw new System.InvalidOperationException("SendMetadataDtoHandler instance in MetadataMessageService doesn't exists!");
}
}
private void deleteFromALLdataServers(MetadataDTO metadataDTO)
{
int n;
foreach (ServerDTO ds in metadataDTO.dataServers)
{
((DataMessageService)Activator.GetObject(typeof(DataMessageService), "tcp://localhost:" + ds.address + "/DataMessageService")).DeleteFile(ds.localFileName);
n = (onlineDataServers.First(info => info.address == ds.address).numFiles--);
Console.WriteLine("Local file \"" + ds.localFileName + "\" deleted on DataServer at " + ds.address + ".");
Console.WriteLine("This DataServer now has " + n + " files.");
}
}
private List <MetadataDTO> GetMetaData(string logicalKnowledgeBaseValue)
{
var metaData = new MetadataDTO()
{
Name = LogicalKnowledgeBaseName,
Value = logicalKnowledgeBaseValue,
};
return(new List <MetadataDTO>()
{
metaData
});
}
// old version not used now
protected MetadataDTO Create(string fileName, int nbDataServers, int readQuorum, int writeQuorum)
{
freezer.WaitOne();
int ticket = getTicket();
int timestamp = getTimestamp();
Dictionary <string, string> dataServers = CreateFileOnServers(fileName, nbDataServers);
MetadataDTO metadataDTO = new MetadataDTO(nbDataServers, readQuorum, writeQuorum, dataServers, ticket);
MetadataContent metadata = new MetadataContent(metadataDTO, __OPEN__, timestamp);
metadataDB.Add(fileName, metadata);
Console.WriteLine("File \"" + fileName + "\" created by client.");
return(metadataDTO);
}
public Metadata(MetadataDTO dto, string fileName)
{
this.nbDataServers = dto.nbDataServers;
this.readQuorum = dto.readQuorum;
this.writeQuorum = dto.writeQuorum;
this.ticket = dto.ticket;
this.dataServers = new Server[dto.dataServers.Length];
this.fileName = fileName;
for (int i = 0; i < dataServers.Length; i++)
{
this.dataServers[i] = new Server(dto.dataServers[i]);
}
}
public IActionResult Post([FromBody] MetadataDTO metadata)
{
try
{
_movieStudioService.AddMovieMetadata(metadata);
return(Ok());
}
catch (Exception ex)
{
//ex.Message can be logged.
return(StatusCode(500, $"Error posting data for movies."));
}
}
private static IEnumerable <DomainDataDTO> RecusiveDomainVisibility(MetadataDTO parent)
{
var metadatas = new List <DomainDataDTO>();
metadatas.Add(new DomainDataDTO {
EntityID = parent.EntityID,
DomainUseID = parent.DomainUseID.Value,
ID = parent.ID,
Visibility = parent.Visibility
});
foreach (var child in parent.ChildMetadata)
{
metadatas.AddRange(RecusiveDomainVisibility(child));
}
return(metadatas);
}
public static IEnumerable <DomainDataDTO> GetReferenceItems(MetadataDTO editDTO, IEnumerable <DomainDataDTO> currentMetaData)
{
List <DTO.DomainDataDTO> metaData = new List <DTO.DomainDataDTO>();
if (!editDTO.IsMultiValue && !editDTO.Value.IsNullOrWhiteSpace())
{
var current = currentMetaData.Where(cm => cm.DomainUseID == editDTO.DomainUseID).FirstOrDefault();
if (current != null && current.DomainReferenceID == Guid.Parse(editDTO.Value))
{
metaData.Add(UpdateDomainData(current, null, 0));
}
else
{
metaData.Add(CreateDomainData(editDTO.DomainUseID.Value, Guid.Parse(editDTO.Value), null, 0));
}
}
else if (editDTO.IsMultiValue)
{
foreach (var child in editDTO.References)
{
if (child.Value != null && child.Value != "" && !string.Equals(child.Value, "false", StringComparison.OrdinalIgnoreCase))
{
if (currentMetaData.Any(cm => cm.DomainUseID == editDTO.DomainUseID && cm.DomainReferenceID == child.ID))
{
string newVal = null;
if (!string.Equals(child.Value, "true", StringComparison.OrdinalIgnoreCase))
{
newVal = child.Value;
}
metaData.Add(UpdateDomainData(currentMetaData.Where(cm => cm.DomainUseID == editDTO.DomainUseID && cm.DomainReferenceID == child.ID).FirstOrDefault(), newVal, 0));
}
else
{
string newVal = null;
if (!string.Equals(child.Value, "true", StringComparison.OrdinalIgnoreCase))
{
newVal = child.Value;
}
metaData.Add(CreateDomainData(editDTO.DomainUseID.Value, child.ID, newVal, 0));
}
}
}
}
return(metaData);
}
private static void LoadMetadata(List <QnADTO> qnADTOs, List <MetadataDTO> metadataDTOs)
{
foreach (QnADTO qnAdto in qnADTOs.ToArray())
{
MetadataDTO[] array = qnAdto.Metadata.ToArray();
for (int index = 0; index < array.Length; ++index)
{
MetadataDTO metadataDto = new MetadataDTO()
{
Name = array[index].Name,
Value = array[index].Value
};
metadataDTOs.Add(metadataDto);
}
}
}
/**
* Consensus Client-Metadata Servers for active replication: send response to client and save metadata of created file
**/
public MetadataDTO createCommit(MetadataQuorumDto dataservers, string fileName, int nbDataServers, int readQuorum, int writeQuorum)
{
MetadataDTO metadataDTO;
freezer.WaitOne();
//next if-else is for load balancing the file creation task for selected metadata server from client
if (dataservers.runCreate(metadataPort))
{
int ticket = getTicket();
int timestamp = dataservers.timestamps[metadataPort - base_port];
Dictionary <string, string> dataServers = CreateFileOnServers(dataservers.Dataservers, fileName, nbDataServers);
metadataDTO = new MetadataDTO(nbDataServers, readQuorum, writeQuorum, dataServers, ticket);
MetadataContent metadata = new MetadataContent(metadataDTO, __OPEN__, timestamp);
metadataDB.Add(fileName, metadata);
for (int i = 0; i < msi.GetLength(0); i++)
{
MetadataServerInfo mi = msi[i];
if (mi != null)
{
//indirect hearbeat for metadata being up or down
try
{
((MetadataMessageService)Activator.GetObject(typeof(MetadataMessageService), "tcp://localhost:" + mi.port + "/DataMessageService")).SendMetadataDto(fileName, metadataDTO, dataservers);
int msID = mi.getID(base_port);
Console.WriteLine("Metadata successfully tranfered from metadata server number " + msID + ".");
}
catch (Exception e)
{
onlineMS[mi.getID(base_port)] = false;
msi[i] = null;
}
}
}
Console.WriteLine("File \"" + fileName + "\" created by client in elected metadata server.");
return(metadataDTO);
}
else
{
throw new System.ApplicationException("createCommit: unexpected run in non elected metadata server");
}
}
private static void LoadMetadata(List <QnADTO> qnaDTOs, List <MetadataDTO> metadataDTO)
{
var metadataArray = qnaDTOs.ToArray();
foreach (var metadata in metadataArray)
{
var metadataFields = metadata.Metadata.ToArray();
for (int i = 0; i < metadataFields.Length; i++)
{
MetadataDTO metadataRecord = new MetadataDTO
{
Id = metadata.Id,
Name = metadataFields[i].Name,
Value = metadataFields[i].Value
};
metadataDTO.Add(metadataRecord);
}
}
}
public void AddMovieMetadata(MetadataDTO movieMetadata)
{
_movieStudioRepository.AddMovieMetadata(movieMetadata);
}
public void ChangeMetadataForFile(string path, MetadataDTO metadata)
{
var _metadata = iMapper.Map <MetadataDTO, Metadata>(metadata);
Project2API.API.MetadataAPI.ChangeMetadataForFile(path, _metadata);
}
public IActionResult SaveMetadata([FromBody] MetadataDTO metadataDto)
{
return(Ok(new { temp = true }));
}
public MetadataDTO GetMetadataChildren(Guid metadataID, IEnumerable <DomainDTO> availableMetadata, IEnumerable <DomainDataDTO> presetMetadata, IEnumerable <DomainDataDTO> visibility, Guid?entityID)
{
var currentMeta = availableMetadata.Where(x => x.ID == metadataID).FirstOrDefault();
var metaData = new MetadataDTO
{
ID = currentMeta.ID,
DataType = currentMeta.DataType,
EntityID = entityID,
EnumValue = currentMeta.EnumValue,
EntityType = currentMeta.EntityType,
IsMultiValue = currentMeta.IsMultiValue,
Title = currentMeta.Title,
DomainUseID = currentMeta.DomainUseID,
};
if (visibility != null)
{
metaData.Visibility = visibility.Where(x => x.ID == metadataID).Select(x => x.Visibility).FirstOrDefault();
}
IList <MetadataDTO> childMetadata = new List <MetadataDTO>();
IList <Dns.DTO.CNDS.DomainReferenceDTO> domainreferences = new List <Dns.DTO.CNDS.DomainReferenceDTO>();
//Filter for the Previously saved parent Metadata
var current = presetMetadata.Where(x => x.DomainUseID == currentMeta.DomainUseID && x.DomainReferenceID == null);
// Setting the Value if exists from the CNDS Database
if (current.Count() > 0)
{
foreach (var cur in current)
{
metaData.Value = cur.Value;
}
}
if (metaData.DataType == "boolean" && current.Count() > 0)
{
metaData.Value = "true";
}
// Fills the Child Metadata where the Parent has Domain References
if (currentMeta.References.Count() > 0)
{
if (!currentMeta.IsMultiValue)
{
var test = (from f in presetMetadata
where f.DomainUseID == currentMeta.DomainUseID
select f);
metaData.Value = presetMetadata.Where(x => x.DomainUseID == currentMeta.DomainUseID).Select(x => x.DomainReferenceID.Value.ToString("D")).FirstOrDefault();
}
foreach (var reference in currentMeta.References)
{
domainreferences.Add(GetMetadataReferences(currentMeta, reference, presetMetadata));
}
metaData.References = domainreferences;
}
//Fills the Child Metadata where a Parent Metadata Exists
if (string.Equals(metaData.DataType, "container", StringComparison.OrdinalIgnoreCase) || string.Equals(metaData.DataType, "booleanGroup", StringComparison.OrdinalIgnoreCase))
{
foreach (var child in availableMetadata.Where(x => x.ParentDomainID == currentMeta.ID))
{
childMetadata.Add(GetMetadataChildren(child.ID, availableMetadata, presetMetadata, visibility, entityID));
}
metaData.ChildMetadata = childMetadata;
}
return(metaData);
}
