public string GetAllActivationLogs(string token)
{
GetAllActivationLogsResult result = new GetAllActivationLogsResult();
try
{
if (!_controlService.ValidateManagementToken(token))
{
result.WasOperationSuccessful = false;
result.WasRequestValid = false;
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}
result.WasRequestValid = true;
result.ActivationLogs = _activationLogService.GetAllActivationLogs();
result.WasOperationSuccessful = true;
}
catch (Exception ex)
{
result.WasException = true;
result.ExceptionMessage = ex.Message; // TODO: Must be modified to hide important data before release
}
return(_controlService.SerializeAndEncryptMgmtOutboundData(result));
}
public string AddProduct(string token, string data)
{
AddProductResult result = new AddProductResult();
try
{
if (!_controlService.ValidateManagementToken(token))
{
result.WasOperationSuccessful = false;
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}
result.WasRequestValid = true;
ServiceProduct product = _controlService.DeserializeAndDencryptMgmtInboundData <ServiceProduct>(data);
_productManagementService.SaveServiceProduct(product);
result.WasOperationSuccessful = true;
}
catch (Exception ex)
{
result.WasException = true;
result.ExceptionMessage = ex.ToString();
}
return(_controlService.SerializeAndEncryptMgmtOutboundData(result));
}
public string SerializeAndEncryptMgmtOutboundData(object o)
{
KeyPair keyPair = _keyPairService.GetManagementKeyPair();
string serializedData = _objectSerializationProvider.Serialize(o);
string encryptedData = _asymmetricEncryptionProvider.EncryptPrivate(serializedData, keyPair);
return(encryptedData);
}
private string SerializeAndEncryptResult(ActivationResult result, KeyPair keyPair)
{
string serializedResult = _serializationProvider.Serialize(result);
string encryptedResult = _asymmetricEncryptionProvider.EncryptPrivate(serializedResult, keyPair);
return(encryptedResult);
}
public Database SaveDatabaseProject(Database databaseProject, string path)
{
if (File.Exists(path))
{
File.Delete(path);
}
// Clear out all the generated data, so we don't serialize that out
foreach (Table t in databaseProject.Tables)
{
foreach (Column c in t.Columns)
{
c.Data = new List <string>();
}
}
string plainTextObjectData;
plainTextObjectData = objectSerializationProvider.Serialize(databaseProject);
string encryptedObjectData;
encryptedObjectData = encryptionProvider.Encrypt(plainTextObjectData, encryptionInfo);
using (StreamWriter writer = new StreamWriter(path))
{
writer.Write(encryptedObjectData);
}
return(GetDatabaseProject(path));
}
public AddProductResult AddProduct(string url, string token,
EncryptionInfo encryptionInfo, KeyPair serviceKeys, ServiceProduct product)
{
ProductsServiceClient client = ProductClientCreator(url);
string encryptedToken = _symmetricEncryptionProvider.Encrypt(token, encryptionInfo);
string serializedPayload = _objectSerializationProvider.Serialize(product);
string encryptedData = _asymmetricEncryptionProvider.EncryptPrivate(serializedPayload, serviceKeys);
string encryptedResult = client.AddProduct(encryptedToken, encryptedData);
string decryptedResult = _asymmetricEncryptionProvider.DecryptPublic(encryptedResult, serviceKeys);
AddProductResult result = _objectSerializationProvider.Deserialize <AddProductResult>(decryptedResult);
return(result);
}
public InitializationResult InitializeService(string url, string token, MasterServiceData data, EncryptionInfo encryptionInfo)
{
StatusServiceClient client = StatusServiceClientCreator(url);
string encryptedToken = _symmetricEncryptionProvider.Encrypt(token, encryptionInfo);
string serializedData = _objectSerializationProvider.Serialize(data);
string encryptedData = _symmetricEncryptionProvider.Encrypt(serializedData, encryptionInfo);
string result = client.InitializeService(encryptedToken, encryptedData);
string decryptedResult = _symmetricEncryptionProvider.Decrypt(result, encryptionInfo);
InitializationResult initializationResult = _objectSerializationProvider.Deserialize <InitializationResult>(decryptedResult);
return(initializationResult);
}
public string GetServiceStatus(string token)
{
StatusRequestResult result = new StatusRequestResult();
if (!_controlService.ValidateManagementToken(token))
{
result.IsActive = false;
result.IsInitialized = false;
result.IsRequestValid = false;
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}
MasterServiceData masterData = _masterService.GetMasterServiceData();
if (masterData == null)
{
result.IsActive = false;
result.IsInitialized = false;
result.IsRequestValid = true;
}
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}
public ActivationResult ActivateLicense(string url, string token, EncryptionInfo encryptionInfo,
LicenseActivationPayload payload, ClientLicense clientLicense)
{
ActivationServiceClient client = ActivationServiceClientCreator(url);
string encryptedToken = _symmetricEncryptionProvider.Encrypt(token, encryptionInfo);
string serializedPayload = _objectSerializationProvider.Serialize(payload);
string encryptedData = _asymmetricEncryptionProvider.EncryptPrivate(serializedPayload, clientLicense.ServicesKeys);
string serviceResult = client.ActivateLicense(encryptedToken, encryptedData);
string result = _asymmetricEncryptionProvider.DecryptPublic(serviceResult, clientLicense.ServicesKeys);
ActivationResult activationResult = _objectSerializationProvider.Deserialize <ActivationResult>(result);
return(activationResult);
}
public static void SerializeMasterServiceData()
{
ICommonRepository commonRepository = ObjectLocator.GetInstance <ICommonRepository>();
IObjectSerializationProvider objectSerializationProvider = ObjectLocator.GetInstance <IObjectSerializationProvider>();
MasterServiceData service = commonRepository.GetMasterServiceData();
string serializedService = objectSerializationProvider.Serialize(service);
if (File.Exists(Directory.GetCurrentDirectory() + "\\MasterService.dat"))
{
File.Delete(Directory.GetCurrentDirectory() + "\\MasterService.dat");
}
using (TextWriter writer = new StreamWriter((Directory.GetCurrentDirectory() + "\\MasterService.dat")))
{
writer.WriteLine(serializedService);
}
}
public static void SerializeServiceData()
{
IServicesService servicesService = ObjectLocator.GetInstance <IServicesService>();
IObjectSerializationProvider objectSerializationProvider = ObjectLocator.GetInstance <IObjectSerializationProvider>();
Service service = servicesService.GetServiceById(2);
string serializedService = objectSerializationProvider.Serialize(service);
if (File.Exists(Directory.GetCurrentDirectory() + "\\Service.dat"))
{
File.Delete(Directory.GetCurrentDirectory() + "\\Service.dat");
}
using (TextWriter writer = new StreamWriter((Directory.GetCurrentDirectory() + "\\Service.dat")))
{
writer.WriteLine(serializedService);
}
}
public MasterConfiguration SaveMasterConfiguration(MasterConfiguration masterConfiguration, EncryptionInfo encryptionInfo)
{
if (File.Exists(Name))
{
File.Delete(Name);
}
string plainTextObjectData;
plainTextObjectData = _objectSerializationProvider.Serialize(masterConfiguration);
string encryptedObjectData;
encryptedObjectData = _encryptionProvider.Encrypt(plainTextObjectData, encryptionInfo);
using (StreamWriter writer = new StreamWriter(Name))
{
writer.Write(encryptedObjectData);
}
return(GetMasterConfiguration(encryptionInfo));
}
public ClientLicense SaveClientLicense(ClientLicense clientLicense, string filePath)
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
string plainTextObjectData;
plainTextObjectData = objectSerializationProvider.Serialize(clientLicense);
string encryptedObjectData;
encryptedObjectData = encryptionProvider.Encrypt(plainTextObjectData, encryptionInfo);
using (StreamWriter writer = new StreamWriter(filePath))
{
writer.Write(encryptedObjectData);
}
return(GetClientLicense(filePath));
}
