public void OnDataReceived(DataPackage dp)
{
if (dp is JoinLobbyPackage)
OnJoinLobby((JoinLobbyPackage)dp);
else if (dp is PlayerReadyPackage)
OnPlayerReady((PlayerReadyPackage)dp);
}
public void SerializeTest_DataPackage_Accelerometer()
{
var dataPackage = new DataPackage<AccelerometerData>();
dataPackage.PhoneData = new PhoneData()
{
PhoneState = PhoneState.Handheld | PhoneState.Left | PhoneState.Walk,
PhoneType = PhoneType.iPhone4,
UpdateInterval = 20
};
dataPackage.Data = new List<AccelerometerData>();
dataPackage.Data.Add(new AccelerometerData() { X = 0.111F, Y = 0.555F, Z = 0.666F });
dataPackage.Data.Add(new AccelerometerData() { X = 0.611F, Y = 0.855F, Z = 0.766F });
var jsonString = Newtonsoft.Json.JsonConvert.SerializeObject(dataPackage);
Assert.IsFalse(string.IsNullOrWhiteSpace(jsonString));
Assert.AreEqual("{\"PhoneData\":{\"PhoneType\":1001,\"PhoneState\":280,\"UpdateInterval\":20},\"Data\":[{\"X\":0.111,\"Y\":0.555,\"Z\":0.666},{\"X\":0.611,\"Y\":0.855,\"Z\":0.766}]}", jsonString);
// {"PhoneData":{"PhoneType":1001,"PhoneState":280,"UpdateInterval":20},"Data":[{"X":0.111,"Y":0.555,"Z":0.666},{"X":0.611,"Y":0.855,"Z":0.766}]}
var newDataPackage = Newtonsoft.Json.JsonConvert.DeserializeObject(jsonString, typeof(DataPackage<AccelerometerData>)) as DataPackage<AccelerometerData>;
Assert.IsNotNull(newDataPackage);
Assert.AreEqual(dataPackage.PhoneData.PhoneState, newDataPackage.PhoneData.PhoneState);
Assert.AreEqual(dataPackage.PhoneData.PhoneType, newDataPackage.PhoneData.PhoneType);
Assert.AreEqual(dataPackage.PhoneData.UpdateInterval, newDataPackage.PhoneData.UpdateInterval);
Assert.AreEqual(dataPackage.Data.Count, newDataPackage.Data.Count);
}
public void OnDataReceived(DataPackage dp)
{
ChatMessagePackage chatMessage = dp as ChatMessagePackage;
if(chatMessage == null)
return;
print("Received chat message: " + chatMessage.Body);
}
public void OnDataReceived(DataPackage dp)
{
if (dp is ResponsePackage)
{
ResponsePackage rp = (ResponsePackage)dp;
ResponseReceived(rp.ResponseId, rp);
waitForResponse.Remove(rp.ResponseId);
}
else if (dp is LobbyUpdatePackage)
{
LobbyUpdatePackage lup = (LobbyUpdatePackage)dp;
if (GetLobbyId(currentLobby) != lup.LobbyId)
return;
currentLobby.clients.Clear();
currentLobby.clients = lup.Members;
if (lup.Start)
{
//c2s.Dispose();
List<TcpClient> clients = new List<TcpClient>();
foreach (var v in currentLobby.clients)
{
clients.Add(NetworkManager.Instance.Client.Connect(v.Key));
}
for (int i = 0; i < clients.Count; i++)
{
if (clients[i].GetRemoteIPEndPoint().Address.Equals(Client.GetLocalIPAddress()))
{
if (i == 0)
NetworkManager.Instance.Client.SetHasToken(true);
TcpClient next = null;
if (i != clients.Count - 1)
next = clients[i + 1];
else
next = clients[0];
if (NetworkManager.Instance.Client.OnLog != null)
{
NetworkManager.Instance.Client.OnLog("Token ring: I am ip " + Client.GetLocalIPAddress() + ", number " + i +
" in the token ring and next in the ring is " + next.GetRemoteIPEndPoint().Address.ToString());
}
NetworkManager.Instance.Client.SetNextTokenClient(next);
break;
}
}
Application.LoadLevel("TerrainMap");
}
}
}
internal DataPackageAdapter( DataPackage dataPackage )
{
Contract.Requires( dataPackage != null );
adapted = dataPackage;
properties = new Lazy<IDataPackagePropertySet>( () => new DataPackagePropertySetAdapter( adapted.Properties ) );
resourceMap = new Lazy<IDictionary<string, IRandomAccessStreamReference>>( () => new VariantDictionaryAdapter<string, RandomAccessStreamReference, IRandomAccessStreamReference>( adapted.ResourceMap ) );
adapted.Destroyed += OnDestoryed;
adapted.OperationCompleted += OnOperationCompleted;
}
public void OnDataReceived(DataPackage dp)
{
if (dp is CreateLobbyPackage)
OnCreateLobby((CreateLobbyPackage)dp);
else if (dp is RequestHighscorePackage)
OnRequestHighscore((RequestHighscorePackage)dp);
else if (dp is RequestLobbyListPackage)
OnRequestLobbyList((RequestLobbyListPackage)dp);
else if (dp is SetHighscorePackage)
OnSetHighscore((SetHighscorePackage)dp);
}
public void Checkin(DataObject dataObject)
{
Log.Verbose("DataObjectRepository Checkin DataObject '{@objectId}'", dataObject.Identity.GetValueAsString());
var dataPackage = new DataPackage(dataObject);
dfsContext.VersionControlService.Checkin(
dataPackage,
VersionStrategy.NEXT_MINOR,
false, // retainLock
new List<string> {"CURRENT"},
null); // operationOptions
}
public void ShowDataPackage()
{
DataObject dataObject = new DataObject(new ObjectIdentity("myRepository"));
DataPackage dataPackage = new DataPackage(dataObject);
DataObject dataObject1 = new DataObject(new ObjectIdentity("myRepository"));
dataPackage.AddDataObject(dataObject1);
foreach (DataObject dataObject2 in dataPackage.DataObjects)
{
Console.WriteLine("Data Object: " + dataObject2);
}
}
/// <summary>
/// The send data.
/// </summary>
/// <param name="data">
/// The data.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public string SendData(IList<TravelRoute> data, IProgressCallback callback)
{
if (data == null || data.Count < 1)
{
return null;
}
var newPkg = new DataPackage<TravelRoute>(data);
var pkgSyncer = this.DataSynchronizer as IPackageSyncer<TravelRoute>;
if (pkgSyncer != null)
{
pkgSyncer.Send(newPkg, callback);
}
return newPkg.Id;
}
public void OnDataReceived(DataPackage dp)
{
FlagPackage fp = dp as FlagPackage;
if (fp == null || fp.FlagId != FlagId)
return;
if (fp.Event == FlagPackage.FlagEvent.PickUp)
{
Owner = GameManager.Instance.GetPlayer(fp.SenderRemoteIPEndpoint.Address);
}
else if (fp.Event == FlagPackage.FlagEvent.Drop)
{
Owner = null;
transform.root.position = GameManager.Instance.getPositionOnTerrain(transform.root.position, TerrainOffset);
}
}
public void WhenCheckout_ThenEverythingIsOk()
{
string objectId = "aaa";
var dp = new DataPackage(CreateDataObject(objectId));
ExpectConfiguration(repository: true);
ExpectVersionControlServiceToCheckout(objectId, dp);
var sut = CreateDataObjectRepository();
var result = sut.Checkout(objectId);
Assert.AreEqual(dp.DataObjects[0], result);
context.VerifyAll();
configuration.VerifyAll();
}
public void OnDataReceived(DataPackage dp)
{
if (dp is BaseCapturePackage)
{
BaseCapturePackage bcp = (BaseCapturePackage)dp;
if (bcp.BaseId != BaseId)
return;
Owner = GameManager.Instance.GetPlayer(bcp.PlayerIP);
int playerIndex = GameManager.Instance.GetPlayers().IndexOf(Owner);
Component[] mrs = transform.root.gameObject.GetComponentsInChildren(typeof(MeshRenderer));
foreach (MeshRenderer mr in mrs)
{
if (mr.material.name.Contains("Material #4"))
mr.material = GameManager.Instance.baseMaterials[playerIndex * 2];
if (mr.material.name.Contains("Material #5"))
mr.material = GameManager.Instance.baseMaterials[playerIndex * 2 + 1];
}
}
}
public void SerializeTest_DataPackage_Gyrosensor()
{
var dataPackage = new DataPackage<GyrosensorData>();
dataPackage.PhoneData = new PhoneData()
{
PhoneState = PhoneState.Handheld | PhoneState.Left | PhoneState.Walk,
PhoneType = PhoneType.iPhone4,
UpdateInterval = 20
};
dataPackage.Data = new List<GyrosensorData>();
dataPackage.Data.Add(new GyrosensorData() { DeltaX = 0.111F, DeltaY = 0.555F, DeltaZ = 0.666F });
dataPackage.Data.Add(new GyrosensorData() { DeltaX = 0.611F, DeltaY = 0.855F, DeltaZ = 0.766F });
var jsonString = Newtonsoft.Json.JsonConvert.SerializeObject(dataPackage);
Assert.IsFalse(string.IsNullOrWhiteSpace(jsonString));
// {"PhoneData":{"PhoneType":1001,"PhoneState":280,"UpdateInterval":20},"Data":[{"DeltaX":0.111,"DeltaY":0.555,"DeltaZ":0.666},{"DeltaX":0.611,"DeltaY":0.855,"DeltaZ":0.766}]}
var newDataPackage = Newtonsoft.Json.JsonConvert.DeserializeObject(jsonString, typeof(DataPackage<GyrosensorData>)) as DataPackage<GyrosensorData>;
Assert.IsNotNull(newDataPackage);
Assert.AreEqual(dataPackage.PhoneData.PhoneState, newDataPackage.PhoneData.PhoneState);
Assert.AreEqual(dataPackage.PhoneData.PhoneType, newDataPackage.PhoneData.PhoneType);
Assert.AreEqual(dataPackage.PhoneData.UpdateInterval, newDataPackage.PhoneData.UpdateInterval);
Assert.AreEqual(dataPackage.Data.Count, newDataPackage.Data.Count);
}
public DataPackage CreateDocumentInFolder(ObjectIdentity objectIdentity)
{
DataPackage dataPackage = new DataPackage(new DataObject(objectIdentity));
OperationOptions operationOptions = null;
return objectService.Create(dataPackage, operationOptions);
}
public void OnDataReceived(DataPackage dp)
{
TokenChangePackage tcp = dp as TokenChangePackage;
if (tcp == null)
return;
hasToken = true;
if (VerboseDebugMessages && OnLog != null)
OnLog("I (" + dp.SenderLocalIPEndpoint.ToString() + ") received the token from " + dp.SenderRemoteIPEndpoint.ToString());
}
public DataPackage CreateContentlessDocument()
{
ObjectIdentity objectIdentity = new ObjectIdentity(DefaultRepository);
DataObject dataObject = new DataObject(objectIdentity, "dm_document");
PropertySet properties = new PropertySet();
properties.Set("object_name", "contentless-" + System.DateTime.Now.Ticks);
dataObject.Properties = properties;
DataPackage dataPackage = new DataPackage(dataObject);
OperationOptions operationOptions = null;
return objectService.Create(dataPackage, operationOptions);
}
public DataPackage CreateFolderAndLinkedDoc()
{
// create a folder data object
String folderName = "a-test-folder-" + System.DateTime.Now.Ticks;
DataObject folderDataObj = new DataObject(new ObjectIdentity(DefaultRepository), "dm_folder");
PropertySet folderDataObjProperties = new PropertySet();
folderDataObjProperties.Set("object_name", folderName);
folderDataObj.Properties = folderDataObjProperties;
// create a contentless document DataObject
String doc1Name = "a-test-doc-" + System.DateTime.Now.Ticks;
DataObject docDataObj = new DataObject(new ObjectIdentity(DefaultRepository), "dm_document");
PropertySet properties = new PropertySet();
properties.Set("object_name", doc1Name);
docDataObj.Properties = properties;
// add the folder as a parent of the folder
ObjectRelationship objRelationship = new ObjectRelationship();
objRelationship.Target = folderDataObj;
objRelationship.Name = Relationship.RELATIONSHIP_FOLDER;
objRelationship.TargetRole = Relationship.ROLE_PARENT;
docDataObj.Relationships.Add(new ObjectRelationship(objRelationship));
// set up the relationship filter to return the doc and folder
RelationshipProfile relationProfile = new RelationshipProfile();
relationProfile.ResultDataMode = ResultDataMode.REFERENCE;
relationProfile.TargetRoleFilter = TargetRoleFilter.ANY;
relationProfile.NameFilter = RelationshipNameFilter.ANY;
relationProfile.DepthFilter = DepthFilter.SPECIFIED;
relationProfile.Depth = 2;
OperationOptions operationOptions = new OperationOptions();
operationOptions.RelationshipProfile = relationProfile;
// create the folder and linked document
DataPackage dataPackage = new DataPackage();
dataPackage.AddDataObject(docDataObj);
return objectService.Create(dataPackage, operationOptions);
}
public static void ProcessTranslatedInputHint(DataPackage package)
{
mainWindow.WriteLine($"Info:{package.Text}");
package.Clear();
}
private void OnGetValue(DataPackage data)
{
ReturnData = new DataPackage(new Items(_view, _viewer));
}
/// <summary>
/// Creazione nuovo sottofascicolo
/// </summary>
/// <param name="folder"></param>
/// <param name="ruolo"></param>
/// <param name="result"></param>
/// <param name="ruoliSuperiori">
/// Ruoli superiori cui è impostata la visibilità del sottofascicolo
/// </param>
/// <returns></returns>
public bool CreateFolder(DocsPaVO.fascicolazione.Folder folder, DocsPaVO.utente.Ruolo ruolo, out DocsPaVO.fascicolazione.ResultCreazioneFolder result, out DocsPaVO.utente.Ruolo[] ruoliSuperiori)
{
bool retValue = false;
result = ResultCreazioneFolder.GENERIC_ERROR;
ruoliSuperiori = null;
try
{
// Recuperare l'ID del padre del folder: dato che la modalità è diversa se il padre
// è Fascicolo o Sottofascicolo, è necessario verificare la casistica
// Caso in cui il parent del sottofascicolo è un sottofascicolo stesso
Qualification qualSottoFascicoloParent = Dfs4DocsPa.getSottofascicoloQualificationById(folder.idParent);
string parentId = DfsHelper.getDctmObjectId(this.GetServiceInstance <IQueryService>(false), qualSottoFascicoloParent);
if (string.IsNullOrEmpty(parentId))
{
// Caso in cui il parent del sottofascicolo è un fascicolo stesso
qualSottoFascicoloParent = Dfs4DocsPa.getFascicoloQualificationById(folder.idFascicolo);
parentId = DfsHelper.getDctmObjectId(this.GetServiceInstance <IQueryService>(false), qualSottoFascicoloParent);
}
if (!string.IsNullOrEmpty(parentId))
{
ObjectIdentity parentIdentity = new ObjectIdentity(new ObjectId(parentId), DctmConfigurations.GetRepositoryName());
ObjectIdentity identity = new ObjectIdentity(DctmConfigurations.GetRepositoryName());
DataObject dataObject = new DataObject(identity, ObjectTypes.SOTTOFASCICOLO);
dataObject.Properties.Properties.AddRange(Dfs4DocsPa.getSottoFascicoloProperties(folder));
dataObject.Relationships.Add(DfsHelper.createParentFolderRelationship(parentIdentity));
// Reperimento ACL del fascicolo di appartenenza e associazione al sottofascicolo
CustomServices.AclDefinition aclDefinition = this.GetAclDefinitionSottoFascicolo(folder);
AclHelper.setAclObjectProperties(dataObject.Properties, aclDefinition);
DataPackage dataPackage = new DataPackage(dataObject);
dataPackage = this.GetServiceInstance <IObjectService>(false).Create(dataPackage, null);
retValue = (dataPackage.DataObjects.Count == 1);
if (retValue)
{
result = ResultCreazioneFolder.OK;
logger.Debug(string.Format("Documentum.CreateFolder: creato sottofascicolo con id {0}", folder.systemID));
}
}
else
{
throw new ApplicationException(string.Format("Non è stato possibile reperire l'oggetto parent per il folder con id '{0}'", folder.systemID));
}
}
catch (Exception ex)
{
retValue = false;
logger.Debug(string.Format("Errore in Documentum.CreateFolder:\n{0}", ex.ToString()));
}
return(retValue);
}
internal DataProviderRequest(DataPackage package, string formatId)
{
_package = package;
FormatId = formatId;
}
private void OnGetValue(DataPackage data)
{
ReturnData = new DataPackage(_stackPanel);
}
/// <summary>
/// Creazione di un nuovo fascicolo in DCTM
/// </summary>
/// <remarks>
///
/// PreCondizioni:
/// Il fascicolo è stato inserito correttamente in DocsPa
/// ed è stato generato un'identificativo univoco
///
/// PostCondizioni:
/// Creato un oggetto in Documentum corrispondente all'oggetto
/// fascicolo di DocsPa. L'oggetto avrà i metadati del fascicolo
/// per la sola consultazione in documentum.
///
/// </remarks>
/// <param name="classifica"></param>
/// <param name="fascicolo"></param>
/// <param name="ruolo"></param>
/// <param name="enableUfficioReferente"></param>
/// <returns></returns>
public bool CreateProject(Classificazione classifica, Fascicolo fascicolo, Ruolo ruolo, bool enableUfficioReferente, out ResultCreazioneFascicolo result)
{
logger.Info("BEGIN");
bool retValue = false;
result = ResultCreazioneFascicolo.GENERIC_ERROR;
CustomServices.AclDefinition aclFascicolo = null;
try
{
//fascicolo.systemID viene SEMPRE valorizzato da ETDOCS; se così non è --> ERRORE
if (string.IsNullOrEmpty(fascicolo.systemID))
{
logger.Debug("Errore passaggio dati da ETDOCS.");
}
else
{
// Reperimento dell'objectidentity relativo al nodo titolario in cui andrà inserito il fascicolo
ObjectIdentity nodoTitolarioIdentity = Dfs4DocsPa.getNodoTitolarioIdentity(fascicolo.idClassificazione);
// Reperimento properties del fascicolo procedimentale
PropertySet props = new PropertySet();
props.Properties.AddRange(Dfs4DocsPa.getFascicoloProcedimentaleProperties(fascicolo));
// Creazione delle ACL per il fascicolo
aclFascicolo = this.CreateAclFascicolo(fascicolo, ruolo);
// Associazione delle ACL al fascicolo da creare
AclHelper.setAclObjectProperties(props, aclFascicolo);
ObjectIdentity identity = new ObjectIdentity(DctmConfigurations.GetRepositoryName());
DataObject dataObject = new DataObject(identity, ObjectTypes.FASCICOLO_PROCEDIMENTALE);
dataObject.Properties = props;
dataObject.Relationships.Add(DfsHelper.createParentFolderRelationship(nodoTitolarioIdentity));
DataPackage dataPackage = new DataPackage(dataObject);
IObjectService objectService = this.GetServiceInstance <IObjectService>(false);
dataPackage = objectService.Create(dataPackage, null);
retValue = (dataPackage.DataObjects.Count == 1);
if (retValue)
{
result = ResultCreazioneFascicolo.OK;
logger.Debug(string.Format("Documentum.CreateProject: creato fascicolo con id {0}", fascicolo.systemID));
}
}
}
catch (Exception ex)
{
retValue = false;
result = ResultCreazioneFascicolo.GENERIC_ERROR;
logger.Debug(string.Format("Errore in Documentum.CreateProject:\n{0}", ex.ToString()));
if (aclFascicolo != null)
{
// Rimozione ACL fascicolo in caso di errore
this.DeleteAcl(aclFascicolo);
}
}
logger.Info("END");
return(retValue);
}
private void OnSetPlane(DataPackage dataPackage)
{
var entity = dataPackage.Get <SceneSelectedEntity>();
LockPlane(GeomUtils.GetFace(entity));
}
private void OnGetPlane(DataPackage data)
{
ReturnData = new DataPackage(_internalFace);
}
public static void ProcessTranslatedInputConfirmation(DataPackage package)
{
package.DelayHandler.Resolve($"({package.Text})");
package.Clear();
}
public void Write(TcpClient client, DataPackage data)
{
Write(client, data.ToString() + Options.NewLineChar);
}
private void OnGetLayerManager(DataPackage data)
{
ReturnData = new DataPackage(_manager);
}
//--------------------------------------
internal DataRequest()
{
Data = new DataPackage();
}
/// <summary>
/// Rimozione di un documento da un folder
/// </summary>
/// <param name="idProfile"></param>
/// <param name="folder"></param>
/// <returns></returns>
public bool RemoveDocumentFromFolder(string idProfile, DocsPaVO.fascicolazione.Folder folder)
{
bool retValue = false;
// Reperimento docNumber da idProfile
logger.Debug("Reperimento docNumber da idProfile");
string docNumber = DocsPaQueryHelper.getDocNumber(idProfile);
bool isStampaRegistro = DocsPaQueryHelper.isStampaRegistroRepertorio(docNumber);
try
{
logger.Debug("getDocumentoIdentityByDocNumber");
ObjectIdentity documentIdentity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(docNumber);
if (isStampaRegistro)
{
documentIdentity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(docNumber);
}
ObjectIdentity folderIdentity = null;
// Verifica se l'id è relativo ad un fascicolo o a un sottofascicolo
logger.Debug("Verifica se l'id è relativo ad un fascicolo o a un sottofascicolo");
if (!DocsPaQueryHelper.isSottofascicolo(folder.systemID))
{
folderIdentity = Dfs4DocsPa.getFascicoloIdentityBySystemId(folder.idFascicolo);
}
else
{
folderIdentity = DctmServices.Dfs4DocsPa.getSottofascicoloIdentityById(folder.systemID);
}
logger.Debug("createRemoveParentFolder");
ReferenceRelationship removeRelationship = DctmServices.DfsHelper.createRemoveParentFolder(folderIdentity);
logger.Debug("updatedDoc.Relationships");
DataObject updatedDoc = new DataObject(documentIdentity);
updatedDoc.Relationships.Add(removeRelationship);
DataPackage dp = new DataPackage(updatedDoc);
logger.Debug("update");
IObjectService objSrvc = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser());
DataPackage retDp = objSrvc.Update(dp, null);
retValue = (retDp.DataObjects.Count > 0);
if (retValue)
{
logger.Debug(string.Format("Documentum.RemoveDocumentFromFolder: rimosso documento con docnumber {0} dal sottofascicolo con id {0}", idProfile, folder.systemID));
}
}
catch (Exception ex)
{
retValue = false;
logger.Debug(string.Format("Errore in Documentum.RemoveDocumentFromFolder:\n{0}", ex.ToString()));
}
return(retValue);
}
public static void ProcessHinterMeaning(DataPackage package)
{
mainWindow.WriteLine($"({package.Text})");
package.Clear();
}
public void ConstructDataObject(String repositoryName, String objName, String objTitle)
{
ObjectIdentity objIdentity = new ObjectIdentity(repositoryName);
DataObject dataObject = new DataObject(objIdentity, "dm_document");
PropertySet properties = dataObject.Properties;
properties.Set("object_name", objName);
properties.Set("title", objTitle);
properties.Set("a_content_type", "gif");
dataObject.Contents.Add(new FileContent("c:/temp/MyImage.gif", "gif"));
DataPackage dataPackage = new DataPackage(dataObject);
}
/// <summary>
/// Rimozione di un documento dal fascicolo (in generale, da tutti i folder presenti nel fascicolo)
/// </summary>
/// <param name="idProfile"></param>
/// <param name="folder"></param>
/// <returns></returns>
public bool RemoveDocumentFromProject(string idProfile, DocsPaVO.fascicolazione.Folder folder)
{
logger.Debug(string.Format("RemoveDocumentFromProject - IdProfile: {0} - IdFolder: {1} - IdFascicolo: {2}", idProfile, folder.systemID, folder.idFascicolo));
// 1. recuperare tutti link del documento
// 2. identificare quelli da rimuovere (tutti quelli sotto il folder in input)
// 3. aggiungere eventualmente il link a documenti non classificati
// (se non c'è neanche più un link residuo)
bool retValue = false;
IObjectService objSrvc = null;
// Reperimento docNumber da idProfile
string docNumber = DocsPaQueryHelper.getDocNumber(idProfile);
bool isStampaRegistro = DocsPaQueryHelper.isStampaRegistroRepertorio(docNumber);
try
{
string repositoryName = DctmConfigurations.GetRepositoryName();
//objSrvc = this.GetObjectServiceInstance();
objSrvc = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser());
List <Relationship> removeRelationships = new List <Relationship>();
// 1. recuperare tutti link del documento:
ObjectIdentity documentIdentity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(docNumber);
if (isStampaRegistro)
{
documentIdentity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(docNumber);
}
logger.Debug("RemoveDocumentFromProject: 1.recuperare tutti link del documento");
List <string> filters = new List <string>();
filters.Add("r_object_id");
DataObject documentData = DfsHelper.getAllPropsAndFolders(objSrvc, documentIdentity, filters, true);
// 2. identificare quelli da rimuovere (tutti quelli sotto il folder in input):
if (documentData.Relationships != null && documentData.Relationships.Count > 0)
{
logger.Debug("RemoveDocumentFromProject: 2. identificare quelli da rimuovere (tutti quelli sotto il folder in input)");
// 2a. recuperiamo la root del nodo associato a Folder:
ObjectIdentity folderIdentity = Dfs4DocsPa.getFascicoloIdentityBySystemId(folder.idFascicolo);
if (folderIdentity.ValueType == ObjectIdentityType.QUALIFICATION)
{
logger.Debug(((Qualification)folderIdentity.Value).GetValueAsString());
}
filters = new List <string>();
filters.Add("r_folder_path");
DataObject folderData = DfsHelper.getAllPropsAndFolders(objSrvc, folderIdentity, filters, false);
Property p = folderData.Properties.Get("r_folder_path");
if (p == null)
{
throw new Exception("Impossibile leggere r_folder_path");
}
string rootPath = p.GetValueAsString();
logger.Debug(string.Format("RemoveDocumentFromProject: RootPath: {0}", rootPath));
foreach (ReferenceRelationship r in documentData.Relationships)
{
// 2b. recuperiamo il path del folder in esame
// qui contiamo sul fatto che gli objectIdentity dei folder a cui è linkato vengano istanziati
// come OBJECT_ID
string targetDctmId = ((ObjectId)r.Target.Value).Id;
logger.Error(string.Format("LOG-DEBUG: RemoveDocumentFromProject: targetDctmId: {0}", targetDctmId));
ObjectIdentity targetIdentity = new ObjectIdentity(new ObjectId(targetDctmId), repositoryName);
DataObject targetData = DfsHelper.getAllPropsAndFolders(objSrvc, targetIdentity, filters, false);
Property prop = targetData.Properties.Properties.Find(e => e.Name == "r_folder_path");
if (prop != null)
{
string targetPath = targetData.Properties.Get("r_folder_path").GetValueAsString();
logger.Debug(string.Format("RemoveDocumentFromProject: targetPath: {0}", targetPath));
//se il target è sotto la root allora è da rimuovere
if (targetPath.StartsWith(rootPath))
{
removeRelationships.Add(DfsHelper.createRemoveParentFolder(targetIdentity));
}
}
}
}
// 3. committare il tutto
DataObject updatedDoc = new DataObject(documentIdentity);
updatedDoc.Relationships = removeRelationships;
DataPackage dp = new DataPackage(updatedDoc);
DataPackage retDp = objSrvc.Update(dp, null);
logger.Debug("RemoveDocumentFromProject: 3. committare il tutto");
if (retDp.DataObjects.Count > 0)
{
retValue = true;
logger.Debug(string.Format("Documentum.RemoveDocumentFromProject: rimosso documento con docnumber {0} dal fascicolo con id {0}", idProfile, folder.systemID));
}
}
catch (Exception e)
{
retValue = false;
logger.Debug(string.Format("Errore in Documentum.RemoveDocumentFromProject:\n{0}", e.ToString()));
}
return(retValue);
}
private void button_Click(object sender, RoutedEventArgs e)
{
string t = "";
int z = 0;
try
{
string s = textBox.Text;
int.TryParse(s, out z);
}
catch (Exception ax) { textBlock3.Text = ax.Message.ToString(); }
if (z <= 0)
{
textBlock3.Text = "Enter passsword length\n(numbers between 1 to 100)";
}
else
{
if (checkBox.IsChecked == true && checkBox1.IsChecked == true && checkBox2.IsChecked == true && checkBox3.IsChecked == true)
{
t = generatePW(65, 91) + generatePW(97, 123) + generatePW(48, 58) + generatePW(32, 48);
}
else if (checkBox1.IsChecked == true && checkBox2.IsChecked == true && checkBox3.IsChecked == true)
{
t = generatePW(97, 123) + generatePW(48, 58) + generatePW(32, 48);
}
else if (checkBox.IsChecked == true && checkBox2.IsChecked == true && checkBox3.IsChecked == true)
{
t = generatePW(65, 91) + generatePW(48, 58) + generatePW(32, 48);
}
else if (checkBox.IsChecked == true && checkBox1.IsChecked == true && checkBox3.IsChecked == true)
{
t = generatePW(65, 91) + generatePW(97, 123) + generatePW(32, 48);
}
else if (checkBox.IsChecked == true && checkBox1.IsChecked == true && checkBox2.IsChecked == true)
{
t = generatePW(65, 91) + generatePW(97, 123) + generatePW(48, 58);
}
else if (checkBox2.IsChecked == true && checkBox3.IsChecked == true)
{
t = generatePW(48, 58) + generatePW(32, 48);
}
else if (checkBox1.IsChecked == true && checkBox3.IsChecked == true)
{
t = generatePW(97, 123) + generatePW(32, 48);
}
else if (checkBox1.IsChecked == true && checkBox2.IsChecked == true)
{
t = generatePW(97, 123) + generatePW(48, 58);
}
else if (checkBox.IsChecked == true && checkBox3.IsChecked == true)
{
t = generatePW(65, 91) + generatePW(32, 48);
}
else if (checkBox.IsChecked == true && checkBox2.IsChecked == true)
{
t = generatePW(65, 91) + generatePW(48, 58);
}
else if (checkBox.IsChecked == true && checkBox1.IsChecked == true)
{
t = generatePW(65, 91) + generatePW(97, 123);
} //same result when n=even
else if (checkBox3.IsChecked == true)
{
t = generatePW(32, 48);
}
else if (checkBox2.IsChecked == true)
{
t = generatePW(48, 58);
}
else if (checkBox1.IsChecked == true)
{
t = generatePW(97, 123);
}
else if (checkBox.IsChecked == true)
{
t = generatePW(65, 91);
}
else
{
textBlock3.Text = "Choose at least one option";
}
// generatePW(x,y);
// if (t.Length / z==2) { for (int i = 1; i < t.Length; i += 2) { v += t[i]; } t = v; }
string pw = shuffleString(preparePW(z, t));
textBox1.Text = pw;
var dt = new DataPackage();
dt.SetText(pw);
Clipboard.SetContent(dt);
}
}
/// <summary>
/// Inserimento di un documento in un folder
/// </summary>
/// <param name="idProfile"></param>
/// <param name="idFolder"></param>
/// <returns></returns>
public bool AddDocumentInFolder(string idProfile, string idFolder)
{
logger.Info("BEGIN");
bool retValue = false;
// Reperimento idfolder per il record di tipo "C" in docspa (root folder)
idFolder = DocsPaQueryHelper.getIdFolderCType(idFolder);
// Reperimento docNumber da idProfile
string docNumber = DocsPaQueryHelper.getDocNumber(idProfile);
//bool stampaRegistro = DocsPaQueryHelper.isStampaRegistro(docNumber);
bool stampaRegistro = DocsPaQueryHelper.isStampaRegistroRepertorio(docNumber);
try
{
IObjectService objectService = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser());
// 1. recuperare il documento con tutti i link a folder attuali
ObjectIdentity documentIdentity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(docNumber);
if (stampaRegistro)
{
documentIdentity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(docNumber);
}
// 2. Creare il nuovo link al folder di classificazione
ObjectIdentity folderIdentity = null;
// Verifica se l'idFolder si riferisce ad un fascicolo o a un sottofascicolo
if (!DocsPaQueryHelper.isSottofascicolo(idFolder))
{
// Reperimento id del fascicolo dal folder (record tipo "C")
string tipoFascicolo;
string idFascicolo = DocsPaQueryHelper.getIdFascicoloFromFolder(idFolder, out tipoFascicolo);
folderIdentity = Dfs4DocsPa.getFascicoloIdentityBySystemId(idFascicolo);
//Effettuo un refresh dei permessi sul fascicolo per allineare le ACL con DOCUMENTUM
//Fascicolo fascicolo = DocsPaQueryHelper.getFascicolo(idFascicolo, this.InfoUtente);
//if (fascicolo != null)
// RefreshAclFascicolo(fascicolo);
}
else
{
folderIdentity = Dfs4DocsPa.getSottofascicoloIdentityById(idFolder);
}
ReferenceRelationship addRelationship = DfsHelper.createParentFolderRelationship(folderIdentity);
//la aggiungeremo alla lista degli update nell'ultimo passo
// 3. salvare
DataObject updatedDoc = new DataObject(documentIdentity);
updatedDoc.Relationships.Add(addRelationship);
// 4. Allineamento ACL documento:
// per coerenza è necessario che, una volta che il documento
// viene inserito in un fascicolo, questo diventi visibile anche
// a tutti gli utenti che hanno la visibilità solo sul fascicolo e
// non sul documento
this.UpdateAclDocumento(idProfile, docNumber);
DataPackage dataPackage = new DataPackage(updatedDoc);
dataPackage = objectService.Update(dataPackage, null);
retValue = (dataPackage.DataObjects.Count > 0);
if (retValue)
{
logger.Debug(string.Format("Documentum.AddDocumentInFolder: inserito il documento con docnumber {0} nel folder con id {1}", idProfile, idFolder));
}
}
catch (Exception ex)
{
retValue = false;
logger.Debug(string.Format("Errore in Documentum.AddDocumentInFolder:\n{0}", ex.ToString()));
}
logger.Info("END");
return(retValue);
}
public void ObjServiceCopyWithMods(String sourceObjectPathString,
String targetLocPathString)
{
// identify the object to copy
ObjectPath objPath = new ObjectPath(sourceObjectPathString);
ObjectIdentity docToCopy = new ObjectIdentity();
docToCopy.Value = objPath;
docToCopy.RepositoryName = DefaultRepository;
// identify the folder to copy to
ObjectPath folderPath = new ObjectPath();
folderPath.Path = targetLocPathString;
ObjectIdentity toFolderIdentity = new ObjectIdentity();
toFolderIdentity.Value = folderPath;
toFolderIdentity.RepositoryName = DefaultRepository;
ObjectLocation toLocation = new ObjectLocation();
toLocation.Identity = toFolderIdentity;
// specify changes to make when copying
DataObject modDataObject = new DataObject(docToCopy);
modDataObject.Type = "dm_document";
PropertySet modProperties = modDataObject.Properties;
String newObjectName = "copiedDocument-" + System.DateTime.Now.Ticks;
modProperties.Set("object_name", newObjectName);
Console.WriteLine("Modified object by changing object name to " + newObjectName);
DataPackage dataPackage = new DataPackage(modDataObject);
ObjectIdentitySet objIdSet = new ObjectIdentitySet();
objIdSet.Identities.Add(docToCopy);
OperationOptions operationOptions = null;
objectService.Copy(objIdSet, toLocation, dataPackage, operationOptions);
}
public static async void CutItem(IShellPage associatedInstance)
{
DataPackage dataPackage = new DataPackage()
{
RequestedOperation = DataPackageOperation.Move
};
ConcurrentBag <IStorageItem> items = new ConcurrentBag <IStorageItem>();
if (associatedInstance.SlimContentPage.IsItemSelected)
{
// First, reset DataGrid Rows that may be in "cut" command mode
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
var itemsCount = associatedInstance.SlimContentPage.SelectedItems.Count;
PostedStatusBanner banner = itemsCount > 50 ? App.OngoingTasksViewModel.PostOperationBanner(
string.Empty,
string.Format("StatusPreparingItemsDetails_Plural".GetLocalized(), itemsCount),
0,
ReturnResult.InProgress,
FileOperationType.Prepare, new CancellationTokenSource()) : null;
try
{
var dispatcherQueue = DispatcherQueue.GetForCurrentThread();
await associatedInstance.SlimContentPage.SelectedItems.ToList().ParallelForEachAsync(async listedItem =>
{
if (banner != null)
{
((IProgress <float>)banner.Progress).Report(items.Count / (float)itemsCount * 100);
}
// FTP don't support cut, fallback to copy
if (listedItem is not FtpItem)
{
_ = dispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, () =>
{
// Dim opacities accordingly
listedItem.Opacity = Constants.UI.DimItemOpacity;
});
}
if (listedItem is FtpItem ftpItem)
{
if (ftpItem.PrimaryItemAttribute is StorageItemTypes.File or StorageItemTypes.Folder)
{
items.Add(await ftpItem.ToStorageItem());
}
}
else if (listedItem.PrimaryItemAttribute == StorageItemTypes.File || listedItem is ZipItem)
{
var result = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
else
{
var result = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
}, 10, banner?.CancellationToken ?? default);
}
catch (Exception ex)
{
if (ex.HResult == (int)FileSystemStatusCode.Unauthorized)
{
// Try again with fulltrust process
var connection = await AppServiceConnectionHelper.Instance;
if (connection != null)
{
string filePaths = string.Join('|', associatedInstance.SlimContentPage.SelectedItems.Select(x => x.ItemPath));
AppServiceResponseStatus status = await connection.SendMessageAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "Clipboard" },
{ "filepath", filePaths },
{ "operation", (int)DataPackageOperation.Move }
});
if (status == AppServiceResponseStatus.Success)
{
banner?.Remove();
return;
}
}
}
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
banner?.Remove();
return;
}
banner?.Remove();
}
var onlyStandard = items.All(x => x is StorageFile || x is StorageFolder || x is SystemStorageFile || x is SystemStorageFolder);
if (onlyStandard)
{
items = new ConcurrentBag <IStorageItem>(await items.ToStandardStorageItemsAsync());
}
if (!items.Any())
{
return;
}
dataPackage.Properties.PackageFamilyName = Windows.ApplicationModel.Package.Current.Id.FamilyName;
dataPackage.SetStorageItems(items, false);
try
{
Clipboard.SetContent(dataPackage);
}
catch
{
dataPackage = null;
}
}
public DataPackage CreateNewFolder()
{
ObjectIdentity folderIdentity = new ObjectIdentity();
folderIdentity.RepositoryName = DefaultRepository;
DataObject dataObject = new DataObject(folderIdentity, "dm_folder");
PropertySet properties = new PropertySet();
String folderName = "aTestFolder-" + System.DateTime.Now.Ticks;
properties.Set("object_name", folderName);
dataObject.Properties = properties;
DataPackage dataPackage = new DataPackage(dataObject);
OperationOptions operationOptions = null;
return objectService.Create(dataPackage, operationOptions);
}
public IActionResult SelectShader([FromBody] DataPackage model)
{
return(Json(new DataPackage()));
}
public DataObject CreateAndLinkToFolder(String folderPath)
{
// create a contentless document to link into folder
String objectName = "linkedDocument" + System.DateTime.Now.Ticks;
Console.WriteLine("Constructed document " + objectName);
String repositoryName = DefaultRepository;
ObjectIdentity sampleObjId = new ObjectIdentity(repositoryName);
DataObject sampleDataObject = new DataObject(sampleObjId, "dm_document");
sampleDataObject.Properties.Set("object_name", objectName);
// add the folder to link to as a ReferenceRelationship
ObjectPath objectPath = new ObjectPath(folderPath);
ObjectIdentity sampleFolderIdentity = new ObjectIdentity(objectPath, DefaultRepository);
ReferenceRelationship sampleFolderRelationship = new ReferenceRelationship();
sampleFolderRelationship.Name = Relationship.RELATIONSHIP_FOLDER;
sampleFolderRelationship.Target = sampleFolderIdentity;
sampleFolderRelationship.TargetRole = Relationship.ROLE_PARENT;
sampleDataObject.Relationships.Add(sampleFolderRelationship);
// create a new document linked into parent folder
OperationOptions operationOptions = null;
DataPackage dataPackage = new DataPackage(sampleDataObject);
DataPackage resultPackage = objectService.Create(dataPackage, operationOptions);
DataObject resultDataObject = resultPackage.DataObjects[0];
return resultDataObject;
}
public ActionResult Index(DataPackage package)
{
return(View());
}
public DataObject UpdateObject(DataObject dataObject)
{
DataPackage dataPackage = new DataPackage();
dataPackage.DataObjects.Add(dataObject);
OperationOptions operationOptions = null;
DataPackage resultDataPackage = objectService.Update(dataPackage, operationOptions);
return resultDataPackage.DataObjects[0];
}
private void Connecting(string userName, string password)
{
#if NETCOREAPP
using (var clientRSA = RSA.Create())
#else
using (var clientRSA = new RSACng())
#endif
{
var clientPK = clientRSA.Export();
using (DataPackage request = new DataPackage("UserName.String.32", "PublicKey.String.256"))
{
request.Headers.Add("ActionID", "Sys.LoginRequest");
request.Headers.Add("UserName", userName);
request.UpdateHeaders();
request.AddNew();
request["UserName"] = userName;
request["PublicKey"] = clientPK;
request.Update();
using (var response = SendAndRecieve(request))
{
if (response.Headers.ContainsKey("Status") &&
(string)response.Headers["Status"] == "ERROR")
{
throw new TCPConnectorException(response);
}
response.GoDataTop();
response.Read();
_loginInfo = new LoginInfo();
_loginInfo.Import(clientRSA.Decrypt(((string)response["LoginInfo"]).ToByteArray(), _padding));
_clientAes = Aes.Create()
.ImportBin(_loginInfo.CryptoKey);
}
}
using (var request = new DataPackage("UserName.String.32", "SessionID.String.34", "EncryptedKey.String.256"))
{
request.Headers.Add("ActionID", "Sys.Logon");
request.Headers.Add("UserName", userName);
request.UpdateHeaders();
request.AddNew();
request["UserName"] = userName;
request["SessionID"] = _loginInfo.SessionID.ToString();
request["EncryptedKey"] = _clientAes
.EncryptBin(Encoding.UTF8.GetBytes(password))
.ToBASE64String();
request.Update();
using (var response = SendAndRecieve(request))
{
if (response.Headers.ContainsKey("Status") &&
(string)response.Headers["Status"] == "ERROR")
{
throw new TCPConnectorException(response);
}
response.GoDataTop();
response.Read();
var token = (string)response["Ticket"];
_ticket = new Guid(_clientAes.DecryptBin(token.ToByteArray()).Take(16).ToArray());
//_ticket = new Guid(((BinaryDataBuffer)_clientAes.DecryptBin(token.ToByteArray())).Slice(0, 16));
//_userName = userName;
Connected = true;
}
}
}
}
public void SendData(DataPackage dp)
{
if (queue.Count != 0)
{
PlayerMovePackage newPmp = dp as PlayerMovePackage;
if (newPmp != null)
{
for (int i = queue.Count - 1; i >= 0; i--)
{
PlayerMovePackage pmp = queue[i] as PlayerMovePackage;
if (pmp == null || pmp.RotationOnly != newPmp.RotationOnly)
continue;
queue.RemoveAt(i);
}
}
}
queue.Add(dp);
}
private static string GetErrorProperty(DataPackage remoteErrorPackage, string key)
{
remoteErrorPackage.GoDataTop();
remoteErrorPackage.Read();
return((string)remoteErrorPackage[key]);
}
public void WriteAll(DataPackage data)
{
foreach (var kvp in clients)
{
Write(kvp.Key, data);
}
}
public DataPackage Execute(string actionID)
{
using (var paramTable = new DataPackage(new string[] { "Default.String.10" }))
return(Execute(actionID, paramTable));
}
private void SetClipboardContent(Entry selectedEntry)
{
DataPackage dataPackage = new DataPackage();
try
{
dataPackage.SetText(selectedEntry.Password);
Clipboard.SetContent(dataPackage);
}
catch (Exception)
{
// ignored
}
}
async private static void OnDataRequested(DataTransferManager sender, DataRequestedEventArgs args)
{
bool didSucceedOperation = false;
var request = args.Request;
switch (_sharingType)
{
case SharingType.Text:
{
if (String.IsNullOrEmpty(TextToShare))
{
request.FailWithDisplayText("Enter the text you would like to share and try again.");
break;
}
DataPackage requestData = request.Data;
requestData.Properties.Title = String.IsNullOrEmpty(Title)? String.Empty: Title;
requestData.Properties.Description = String.IsNullOrEmpty(Description) ? String.Empty : Description;
requestData.Properties.ContentSourceApplicationLink = String.IsNullOrEmpty(Url) ? new Uri(String.Empty) : new Uri(Url, UriKind.RelativeOrAbsolute);
requestData.SetText(String.IsNullOrEmpty(TextToShare) ? String.Empty : TextToShare);
didSucceedOperation = true;
break;
}
case SharingType.Image:
{
DataRequestDeferral deferral = request.GetDeferral();
StorageFile imageFile = await Package.Current.InstalledLocation.GetFileAsync(ImageFilePath);
if (imageFile == null)
{
didSucceedOperation = false;
return;
}
DataPackage requestData = request.Data;
requestData.Properties.Title = String.IsNullOrEmpty(Title) ? String.Empty : Title;
requestData.Properties.Description = String.IsNullOrEmpty(Description) ? String.Empty : Description;
List <IStorageItem> imageItems = new List <IStorageItem>();
imageItems.Add(imageFile);
requestData.SetStorageItems(imageItems);
RandomAccessStreamReference imageStreamRef = RandomAccessStreamReference.CreateFromFile(imageFile);
requestData.Properties.Thumbnail = imageStreamRef;
requestData.SetBitmap(imageStreamRef);
didSucceedOperation = true;
deferral.Complete();
break;
}
case SharingType.HTML:
{
// Get the user's selection from the WebView. Since this is an asynchronous operation we need to acquire the deferral first.
DataRequestDeferral deferral = request.GetDeferral();
// Make sure to always call Complete when done with the deferral.
try
{
DataPackage requestData = request.Data;
requestData.Properties.Title = "A web snippet for you";
requestData.Properties.Description = "HTML selection from a WebView control"; // The description is optional.
requestData.Properties.ContentSourceApplicationLink = String.IsNullOrEmpty(Url) ? new Uri(String.Empty) : new Uri(Url, UriKind.RelativeOrAbsolute);
string data = Windows.ApplicationModel.DataTransfer.HtmlFormatHelper.CreateHtmlFormat(HTMLContent);
request.Data.SetHtmlFormat(data);
deferral.Complete();
didSucceedOperation = true;
}
catch (Exception)
{
deferral.Complete();
}
break;
}
default:
{
break;
}
}
if (!didSucceedOperation)
{
if (_onShareCompleted != null)
{
Utils.RunOnUnityAppThread(() =>
{
_onShareCompleted(new CallbackResponse {
Exception = new Exception("Sharing failed because parameters are not set correctly"), Status = CallbackStatus.Failure
});
return;
});
}
}
}
private void OnRefresh(DataPackage data)
{
_manager.Draw();
_viewer.Update();
}
private void OnGetValue(DataPackage data)
{
ReturnData = new DataPackage(_globalCapabilities);
}
private void OnResize(DataPackage data)
{
_view.MustBeResized();
}
public void CreateParentChildRelationship(DataObject parentObject, DataObject childObject, string relationshipType)
{
Guard.IsNotNull(parentObject, "parentObject");
Guard.IsNotNull(childObject, "childObject");
Guard.IsNotNull(relationshipType, "relationType");
var relationId = new ObjectIdentity(dfsConfiguration.Repository);
var relationObject = new DataObject(relationId, DocumentumTypes.DocumentumRelationship);
relationObject.Properties.Set("relation_name", relationshipType);
relationObject.Properties.Set("parent_id", parentObject.Identity.GetValueAsString() );
relationObject.Properties.Set("child_id", childObject.Identity.GetValueAsString() );
var dataPackage = new DataPackage(relationObject);
dfsContext.ObjectService.Create(dataPackage, null);
}
private Task Receiver(NetworkStream stream, CancellationTokenSource cts)
{
return(new Task(() =>
{
Trace.TraceInformation("Receiver task starting...");
//stream.ReadTimeout = 5000;
try
{
while (true)
{
if (cts.Token.IsCancellationRequested)
{
break;
}
DataPackage dataPackage = DataPackage.FromStream(stream);
switch (dataPackage.Type)
{
case MessageType.SYSTEM_LOGIN_OK:
{
LoginInfo info = Serializer.Deserialize <LoginInfo>(dataPackage.Data);
Name = info.Name;
LoginOK?.Invoke(this, info);
}
break;
case MessageType.SYSTEM_LOGIN_FAILED:
{
LoginInfo info = Serializer.Deserialize <LoginInfo>(dataPackage.Data);
LoginFailed?.Invoke(this, info);
}
break;
case MessageType.SYSTEM_JOIN_ROOM_OK:
{
RoomInfo roomInfo = Serializer.Deserialize <RoomInfo>(dataPackage.Data);
JoinedInRoom?.Invoke(this, roomInfo);
}
break;
case MessageType.SYSTEM_LEAVE_ROOM_OK:
{
RoomInfo roomInfo = Serializer.Deserialize <RoomInfo>(dataPackage.Data);
LeavedFromRoom?.Invoke(this, roomInfo);
}
break;
case MessageType.CLIENT_MESSAGE:
{
Message message = Serializer.Deserialize <Message>(dataPackage.Data);
MessageReceived?.Invoke(this, message);
}
break;
case MessageType.CLIENT_IMAGE_MESSAGE:
{
var imageMessage = Serializer.Deserialize <ImageMessage>(dataPackage.Data);
ImageMessageReceived?.Invoke(this, imageMessage);
}
break;
case MessageType.CLIENT_FILE_MESSAGE:
{
var fileMessage = Serializer.Deserialize <FileMessage>(dataPackage.Data);
FileMessageReived?.Invoke(this, fileMessage);
}
break;
case MessageType.SYSTEM_FILE_TRANSFER:
{
var fileMessage = Serializer.Deserialize <FileMessage>(dataPackage.Data);
FileReived?.Invoke(this, fileMessage);
}
break;
case MessageType.SYSTEM_MESSAGE_OK:
{
Receipt receipt = Serializer.Deserialize <Receipt>(dataPackage.Data);
MessageArrivied?.Invoke(this, receipt);
}
break;
case MessageType.SYSTEM_MESSAGE:
{
var message = Encoding.UTF8.GetString(dataPackage.Data);
SystemMessageReceived?.Invoke(this, message);
break;
}
case MessageType.CLIENT_LOGOUT:
{
Name = null;
LogoutOK?.Invoke(this, null);
goto default;
}
default:
UnknownMessageReceived?.Invoke(this, new SystemMessageEventArgs(dataPackage.Type, dataPackage.Data));
break;
}
}
}
catch (EndOfStreamException ex)
{
Debug.WriteLine($"Client {Name} Receiver: {ex.Message}");
}
catch (IOException ex)
{
if (ex.InnerException is SocketException)
{
SocketExceptionRaising?.Invoke(this, (SocketException)ex.InnerException);
}
else
{
Trace.TraceInformation($"{ex}");
}
}
ReceiverTaskExited?.Invoke(this, null);
Trace.TraceInformation("Receiver task exited");
}, TaskCreationOptions.LongRunning));
}
public Task <DataPackage> InvokeAsync(ActionInfo ai, DataPackage dp)
{
throw new NotImplementedException();
}
public virtual async void CutItem(RoutedEventArgs e)
{
DataPackage dataPackage = new DataPackage
{
RequestedOperation = DataPackageOperation.Move
};
List <IStorageItem> items = new List <IStorageItem>();
FilesystemResult result = (FilesystemResult)false;
if (SlimContentPage.IsItemSelected)
{
// First, reset DataGrid Rows that may be in "cut" command mode
SlimContentPage.ResetItemOpacity();
foreach (ListedItem listedItem in SlimContentPage.SelectedItems)
{
// Dim opacities accordingly
SlimContentPage.SetItemOpacity(listedItem);
if (listedItem.PrimaryItemAttribute == StorageItemTypes.File)
{
result = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
break;
}
}
else
{
result = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
break;
}
}
}
if (result.ErrorCode == FileSystemStatusCode.NotFound)
{
SlimContentPage.ResetItemOpacity();
return;
}
else if (result.ErrorCode == FileSystemStatusCode.Unauthorized)
{
// Try again with fulltrust process
if (ServiceConnection != null)
{
string filePaths = string.Join('|', SlimContentPage.SelectedItems.Select(x => x.ItemPath));
AppServiceResponseStatus status = await ServiceConnection.SendMessageAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "Clipboard" },
{ "filepath", filePaths },
{ "operation", (int)DataPackageOperation.Move }
});
if (status == AppServiceResponseStatus.Success)
{
return;
}
}
SlimContentPage.ResetItemOpacity();
return;
}
}
if (!items.Any())
{
return;
}
dataPackage.SetStorageItems(items);
try
{
Clipboard.SetContent(dataPackage);
Clipboard.Flush();
}
catch
{
dataPackage = null;
}
}
private void OnSwitchView(DataPackage data)
{
var planeDirection = (data.Data as gpPln).Axis.Direction;
_view.SetProj(planeDirection.X, planeDirection.Y, planeDirection.Z);
}
private void CommandInitialize()
{
AddAccountCommand = new RelayCommand <TwitterAccount>(account =>
{
account.OnTweetBegin += (status) => MessengerInstance.Send <PostStatusBase>(status, "OnTweetBegin");
account.OnTweetFailed += async(status) =>
{
await NotificationAsync(new NotificationMessage {
TweetMessage = Tweet.ZeroTweet,
Message = "ツイートの送信に失敗しました"
});
MessengerInstance.Send <PostStatusBase>(status, "OnTweetFailed");
};
account.OnTweetCompleted += (status) => MessengerInstance.Send <PostStatusBase>(status, "OnTweetCompleted");
account.OnHttpGetError += async(e) =>
{
await NotificationAsync(new NotificationMessage
{
TweetMessage = Tweet.ZeroTweet,
Message = e.Message
});
MessengerInstance.Send <HttpRequestException>(e, "OnHttpGetError");
};
account.OnHttpPostError += async(e) =>
{
await NotificationAsync(new NotificationMessage
{
TweetMessage = Tweet.ZeroTweet,
Message = e.Message
});
MessengerInstance.Send <HttpRequestException>(e, "OnHttpPostError");
};
account.OnUserStreamHttpError += async(e) =>
{
await NotificationAsync(new NotificationMessage
{
TweetMessage = Tweet.ZeroTweet,
Message = e.Message
});
MessengerInstance.Send <HttpRequestException>(e, "OnUserStreamHttpError");
};
account.OnFollowStreamHttpError += async(e) =>
{
await NotificationAsync(new NotificationMessage
{
TweetMessage = Tweet.ZeroTweet,
Message = e.Message
});
MessengerInstance.Send <HttpRequestException>(e, "OnFollowStreamHttpError");
};
account.ChangeUserStreamEvent += async(state) =>
{
switch (state)
{
case StreamState.Connect:
// await NotificationAsync("Stream Connected");
await SharedDispatcher.RunAsync(() =>
{
ConnectionStatusStr = "Stream Connected";
});
break;
case StreamState.TryConnect:
// await NotificationAsync("Stream TryConnected");
await SharedDispatcher.RunAsync(() =>
{
ConnectionStatusStr = "Stream TryConnected";
});
break;
case StreamState.DisConnect:
// await NotificationAsync("Stream DisConnect");
await SharedDispatcher.RunAsync(() =>
{
ConnectionStatusStr = "Stream DisConnected";
});
break;
}
};
this.AccountList.Add(account);
});
DeleteAccountCommand = new RelayCommand <TwitterAccount>(account =>
{
this.AccountList.Remove(account);
});
PostStatusCommand = new RelayCommand(async() =>
{
if (!AccountList.Where(q => q.IsActive == true).Select(q => q).Any())
{
Tweet tweet = Tweet.ZeroTweet;
await NotificationAsync(new NotificationMessage {
TweetMessage = Tweet.ZeroTweet,
Message = "アカウントが選択されていません"
});
}
else
{
PostStatusBase status = TwitterUIComponent.GetPostStatus();
status.Status += " " + Setting.Footer;
DeletePostImageCommand.Execute(null);
TwitterUIComponent.ResetPostText();
await ActionSelectedAccountAsync(async(client) =>
{
if (status is PostStatus)
{
await client.UpdateStatusAsync(status as PostStatus);
}
else if (status is PostStatusWithReply)
{
await client.UpdateStatusAsync(status as PostStatusWithReply);
}
else if (status is PostStatusMedia)
{
await client.UpdateStatusWithMediaAsync(status as PostStatusMedia);
}
else if (status is PostStatusMediaWithReply)
{
await client.UpdateStatusWithMediaAsync(status as PostStatusMediaWithReply);
}
});
}
});
AddTimelineTabCommand = new RelayCommand <TimelineTab>(tab =>
{
AddTimelineTab(tab);
});
DeleteTimelineTabCommand = new RelayCommand <TimelineTab>(tab =>
{
foreach (TimelineBase timeline in tab.TimelineList)
{
timeline.DeleteTimeLine();
}
TimelineListTab.Remove(tab);
if (TimelineListTab.Count > 0)
{
var t = TimelineListTab.Take(1).Single();
ChangeTabAsync(t);
}
MessengerInstance.Send <TimelineTab>(tab, "DeleteTimelineTab");
});
AddTimelineCommand = new RelayCommand <TimelineBase>(timeline =>
{
GetNowTab().TimelineList.Add(timeline);
timeline.AddTimeLine();
ResetTimeline();
MessengerInstance.Send <TimelineBase>(timeline, "AddTimeline");
});
DeleteTimelineCommand = new RelayCommand <TimelineBase>(timeline =>
{
GetNowTab().TimelineList.Remove(timeline);
timeline.DeleteTimeLine();
ResetTimeline();
MessengerInstance.Send <TimelineBase>(timeline, "DeleteTimeline");
});
ChangeTabCommand = new RelayCommand <TimelineTab>(tab =>
{
ChangeTabAsync(tab);
MessengerInstance.Send <TimelineTab>(tab, "ChangeTab");
});
EditTimelineTabCommand = new RelayCommand <TimelineTab>(tab =>
{
this.nowEditTimelineTab = tab;
MessengerInstance.Send <TimelineTab>(tab, "EditTimelineTab");
});
EditTimelineCommand = new RelayCommand <TimelineBase>(timeline =>
{
this.nowEditTimeline = timeline;
MessengerInstance.Send <TimelineBase>(timeline, "EditTimeline");
});
FavoriteCommand = new RelayCommand <Tweet>(async tweet =>
{
await ActionSelectedAccountWithUiAsync(async client =>
{
if (tweet.favorited == false)
{
tweet.favorited = true;
await client.CreateFavoriteAsync(tweet);
}
else
{
tweet.favorited = false;
await client.DestroyFavoriteAsync(tweet);
}
});
});
RetweetCommand = new RelayCommand <Tweet>(async tweet =>
{
await ActionSelectedAccountWithUiAsync(async client =>
{
if (tweet.retweeted == false)
{
tweet.retweeted = true;
await client.CreateRetweetAsync(tweet);
}
else
{
tweet.retweeted = false;
//await client.DestroyRetweetAsync(tweet);
}
});
});
QuoteCommand = new RelayCommand <Tweet>(tweet => this.TwitterUIComponent.SetPostText(" RT @" + tweet.user.screen_name + " " + tweet.text));
TweetDetailCommand = new RelayCommand <TweetDetailParameter>(async tweet =>
{
this.MessengerInstance.Send <TweetDetail>(TweetDetail, "ShowTweetDetail");
this.TweetDetail.OwnerAccount = GetAccount(tweet.OwnerScreenName);
this.TweetDetail.Set(new TimelineRow(tweet.tweet, "", Setting, CallRowAction),
(await GetAccount(tweet.OwnerScreenName).TwitterClient.GetConversationAsync(tweet.tweet)).Select(q => new TimelineRow(q, tweet.OwnerScreenName, Setting, CallRowAction)).ToList());
});
ReplyCommand = new RelayCommand <Tweet>(tweet =>
{
this.TwitterUIComponent.AddPostText("@" + tweet.user.screen_name + " ", tweet);
Messenger.Default.Send <int>(TwitterUIComponent.PostText.Length, "SetPostTextCursor");
});
DescriptionDommand = new RelayCommand <Tweet>(tweet =>
{
this.TwitterUIComponent.SetPostText("(@" + tweet.user.screen_name + ")");
Messenger.Default.Send <int>(0, "SetPostTextCursor");
});
UserDetailCommand = new RelayCommand <UserDetailParameter>(async screen_name =>
{
this.MessengerInstance.Send <UserDetail>(UserDetail, "ShowUserDetail");
this.UserDetail.OwnerAccount = GetAccount(screen_name.OwnerScreenName);
this.UserDetail.Set(await GetAccount(screen_name.OwnerScreenName).TwitterClient.GetAccountInformationAsync(screen_name.ScreenName), (await GetAccount(screen_name.OwnerScreenName).TwitterClient.GetUserTimeLineAsync(screen_name.ScreenName, 100)).Select(q => new TimelineRow(q, screen_name.OwnerScreenName, Setting, CallRowAction)).ToList());
});
SearchCommand = new RelayCommand <SearchDetailParameter>(async searchWord =>
{
this.MessengerInstance.Send <SearchDetail>(SearchDetail, "ShowSearchDetail");
this.SearchDetail.OwnerAccount = GetAccount(searchWord.OwnerScreenName);
this.SearchDetail.Set(searchWord.SearchWord, (await GetAccountFirst().TwitterClient.GetSearchAsync(searchWord.SearchWord, 100)).statuses.Select(q => new TimelineRow(q, searchWord.OwnerScreenName, Setting, CallRowAction)).ToList());
});
BrowseCommand = new RelayCommand <string>(url => this.MessengerInstance.Send <string>(url, "BrowsUrl"));
BeginAuthCommand = new RelayCommand(async() =>
{
string requestUrl = await Authorizer.BeginAuthorizedAsync(this.ConsumerData);
this.MessengerInstance.Send <string>(requestUrl, "GetAuthorizedUrl");
});
PinAuthCommand = new RelayCommand <string>(async pin =>
{
TokenResponse <AccessToken> res = null;
try
{
res = await Authorizer.PinAuthorizedAsync(pin);
var name = res.ExtraData["screen_name"].ElementAt(0);
var account = new TwitterAccount(ConsumerData, new AccessTokenData(res.Token.Key, res.Token.Secret), name);
await account.InitializeAsync();
account.IsActive = true;
AddAccountCommand.Execute(account);
var tab = new TimelineTab(name + " - MainTab", CallTabAction, CallTimelineAction, CallRowAction);
AddTimelineTab(tab);
AddTimelineCommand.Execute(new HomeTimeline(account, "Home", tab.TabTitle, Setting, CallTimelineAction, CallRowAction));
AddTimelineCommand.Execute(new MentionTimeline(account, "Mention", tab.TabTitle, Setting, CallTimelineAction, CallRowAction)
{
IsNewNotification = true
});
var tab2 = new TimelineTab(name + " - SubTab", CallTabAction, CallTimelineAction, CallRowAction);
AddTimelineTab(tab2);
AddTimelineCommand.Execute(new NotificationTimeline(account, "Notification", tab2.TabTitle, Setting, CallTimelineAction, CallRowAction)
{
IsNewNotification = true
});
AddTimelineCommand.Execute(new UserTimeline(account, "@" + name, tab2.TabTitle, name, Setting, CallTimelineAction, CallRowAction));
ChangeTabAsync(tab);
this.MessengerInstance.Send <bool>(true, "AuthorizedCompleted");
}
catch (Exception e)
{
this.MessengerInstance.Send <bool>(false, "AuthorizedCompleted");
}
});
SetPostImageCommand = new RelayCommand <PostMedia>(media =>
{
TwitterUIComponent.SetPostMedia(media);
});
DeletePostImageCommand = new RelayCommand(() =>
{
TwitterUIComponent.ResetPostMedia();
MessengerInstance.Send <string>("", "DeletePostImage");
});
SelectSuggestCommand = new RelayCommand <string>(item =>
{
if (item.StartsWith("@") && TwitterUIComponent.PostText.Contains("@"))
{
var ss = TwitterUIComponent.PostText;
int index = ss.LastIndexOf("@", System.StringComparison.Ordinal);
string s = ss.Substring(0, index);
TwitterUIComponent.PostText = s + item + " ";
}
else if (item.StartsWith("#") && TwitterUIComponent.PostText.Contains("#"))
{
var ss = TwitterUIComponent.PostText;
int index = ss.LastIndexOf("#", System.StringComparison.Ordinal);
string s = ss.Substring(0, index);
TwitterUIComponent.PostText = s + item + " ";
}
});
ToggleAccountActivityCommand = new RelayCommand <TwitterAccount>(account => account.ToggleActivity());
DirectMessageDetailCommand = new RelayCommand <DirectMessageDetailParameter>(async dm =>
{
MessengerInstance.Send <DirectMessage>(dm.Message, "ShowDirectMessageDetail");
this.directMesssageDetail.OwnerAccount = GetAccount(dm.OwnerScreenName);
this.directMesssageDetail.DMessage = dm.Message;
this.directMesssageDetail.Conversations.Clear();
var dms = (await GetAccount(dm.OwnerScreenName).TwitterClient.GetDirectMessages());
var conv = dms.Where(q => (q.sender_screen_name == dm.Message.sender_screen_name &&
q.recipient_screen_name == dm.Message.recipient_screen_name) ||
(q.sender_screen_name == dm.Message.recipient_screen_name &&
q.recipient_screen_name == dm.Message.sender_screen_name)
).Select(q => q).ToList();
foreach (var c in conv)
{
this.directMesssageDetail.Conversations.Add(new DirectMessageRow(c, dm.OwnerScreenName, Setting, CallRowAction));
}
});
SendDirectMessageCommand = new RelayCommand <SendDirectMessage>(async message =>
{
await GetAccount(message.SenderScreenName).TwitterClient.PostDirectMessageNew(message.RecipientScreenName, message.Message);
});
ChangeTimelineWidthCommand = new RelayCommand <double>(size =>
{
this.TimelineWidth = size;
foreach (var timeline in NowTimelineList)
{
timeline.TimelineWidth = size;
}
});
ExitCommand = new RelayCommand(async() =>
{
await SaveSettingDataAsync();
await SaveTwitterDataAsync();
Application.Current.Exit();
});
AddSuggestPostText = new RelayCommand <string>(str =>
{
TwitterUIComponent.SetPostText(TwitterUIComponent.PostText.Substring(0, TwitterUIComponent.PostText.Count() - 1));
TwitterUIComponent.AddPostText(str + " ");
});
ChangeUIBrushImageCommand = new RelayCommand <string>(str =>
{
MessengerInstance.Send <string>(str, "ChangeUIBrushImage");
});
ResetThemeSettingCommand = new RelayCommand(() =>
{
Setting.SettingInitialize();
});
PurchaseApplicationThemeCommand = new RelayCommand(async() =>
{
if (!LicenseInfo.ProductLicenses["ApplicationTheme"].IsActive)
{
var result = await CurrentApp.RequestProductPurchaseAsync("ApplicationTheme");
if (result.Status == ProductPurchaseStatus.Succeeded)
{
MessageDialog dialog = new MessageDialog("Thank you for purchase Neuronia CusomAppTheme! Enjoy Neuronia and Twitter Life!", "Thank You!");
await dialog.ShowAsync();
IsPurchase = LicenseInfo.ProductLicenses["ApplicationTheme"].IsActive;
}
}
});
AddMuteAccountCommand = new RelayCommand <string>(async(screenName) =>
{
Setting.MuteAccountList.Add(screenName);
await NotificationAsync(new NotificationMessage {
TweetMessage = Tweet.ZeroTweet,
Message = "Mute Complate @" + screenName
});
});
CopyClipBoardCommand = new RelayCommand <string>(async str =>
{
var package = new DataPackage();
package.SetText(str);
Clipboard.SetContent(package);
await NotificationAsync(new NotificationMessage {
TweetMessage = Tweet.ZeroTweet,
Message = "Copy Completed! " + str
});
});
NextTabCommand = new RelayCommand(() =>
{
var num = TimelineListTab.TakeWhile(q => q.IsNowTab).Select(q => q).Count() - 1;
if (num != TimelineListTab.Count - 1)
{
ChangeTabAsync(TimelineListTab.ElementAt(++num));
}
});
PrevTabCommand = new RelayCommand(() =>
{
var num = TimelineListTab.TakeWhile(q => q.IsNowTab).Select(q => q).Count() + 1;
if (num != 0)
{
ChangeTabAsync(TimelineListTab.ElementAt(--num));
}
});
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
HTMLSource.Navigate(new Uri("ms-appx-web:///SampleHTML.html"));
d = new DataPackage();
}
