public static void Main(string[] args)
{
Console.WriteLine(AmlRiderLogo.Replace("@", Environment.NewLine));
Console.WriteLine("For help use the --help flag!" + Environment.NewLine);
new CommandLineParser()
.Parse(args, typeof(ConvertOptions), typeof(PackageOptions))
.WithParsed <ConvertOptions>(OnConvertOptionsParsed)
.WithParsed <PackageOptions>(OnPackageOptionsParsed);
if (HasParsedArgs || args.Length < 1)
{
return;
}
var path = args[0];
if (!File.Exists(path))
{
Console.WriteLine($"The file {path} does not exist.");
return;
}
var outputFile = ConstructOutputFilePath(path);
if (!ShouldOverride(outputFile))
{
return;
}
var fileText = ReadFile(path);
var outputXml = ConversionHandler.Convert(fileText, outputFile);
File.WriteAllText(outputFile, outputXml);
}
// Advanced example
public static void ToSlidesAdvance()
{
// Setup Conversion configuration
var conversionConfig = new ConversionConfig {
StoragePath = storagePath, CachePath = cachePath
};
conversionConfig.SetUseCache(true);
//instantiating the conversion handler
var conversionHandler = new ConversionHandler(conversionConfig);
//Set password to unprotect protected document during loading
LoadOptions loadOptions = new LoadOptions {
Password = "******"
};
// convert file to Ppt, starting from page 2 and convert 2 pages,
// use DPI 300, image width 1024, image height 768
SaveOptions saveOptions = new SlidesSaveOptions
{
ConvertFileType = SlidesSaveOptions.SlidesFileType.Ppt,
PageNumber = 2,
NumPagesToConvert = 2,
};
var convertedDocumentStream = conversionHandler.Convert <Stream>(inputGUIDFile, loadOptions, saveOptions);
}
static void Main()
{
const string sourceFileName = "sample.doc"; //TODO: Put the source filename here
const string resultFileName = "result.pdf"; //TODO: Put the result filename here
// Setup Conversion configuration
var conversionConfig = new ConversionConfig
{
CachePath = "cache",
StoragePath = "."
};
conversionConfig.SetUseCache(true);
var inputDataHandler = new AmazonInputDataHandler();
var cacheDataHandler = new AmazonCacheDataHandler(conversionConfig);
var conversionHandler = new ConversionHandler(conversionConfig, inputDataHandler, cacheDataHandler);
var resultStream = conversionHandler.Convert <Stream>(sourceFileName, new PdfSaveOptions());
WriteStreamToFile(resultStream, resultFileName);
resultStream.Dispose();
Console.WriteLine("The conversion finished. Press <<ENTER>> to exit.");
Console.ReadLine();
}
public static async Task HandleViewCommentsPhoto(FileServer.Server server, CommunicationClient client)
{
var photoIdParsed = ConversionHandler.ConvertBytesToLong(await client.StreamCommunication.ReadAsync(ProtocolConstants.LongTypeLength));
ProtocolHelpers.SendResponseCommand(ProtocolConstants.ResponseCommands.ListComments,
client.StreamCommunication);
var photo = new PhotoDto()
{
Id = photoIdParsed
};
var comments = await server.Service.GetCommentsAsync(photo);
var length = comments.Count() * (User.UserEmailLength + User.UserNameLength + Comment.CommentLength);
var data = ConversionHandler.ConvertIntToBytes(length);
client.StreamCommunication.Write(data);
comments.ToList().ForEach((elem) =>
{
var comment = new Comment()
{
Message = elem.Message,
Commentator = new User()
{
Email = elem.UserEmail,
Name = elem.UserName
}
};
ProtocolHelpers.SendCommentData(client.StreamCommunication, comment);
});
loggerService.SendMessages("Comments listed correctly");
}
public static async Task HandleViewPhotos(Server server, CommunicationClient client)
{
ProtocolHelpers.SendResponseCommand(ProtocolConstants.ResponseCommands.ListPhotos,
client.StreamCommunication);
var photos = await server.Service.GetPhotosAsync();
var length = photos.Count() * (User.UserEmailLength + ProtocolConstants.LongTypeLength + Photo.PhotoNameLength + Photo.PhotoExtensionLength + ProtocolConstants.LongTypeLength);
var data = ConversionHandler.ConvertIntToBytes(length);
client.StreamCommunication.Write(data);
photos.ForEach((elem) =>
{
var photo = new Photo()
{
Id = elem.Id,
Name = elem.Name,
Extension = elem.Extension,
FileSize = elem.FileSize,
User = new User()
{
Email = elem.UserEmail
}
};
ProtocolHelpers.SendPhotoData(client.StreamCommunication, photo);
});
loggerService.SendMessages("Images listed correctly");
}
public static async Task <bool> ValidateLogin(Server server, CommunicationClient client)
{
var email = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(User.UserEmailLength));
var password = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(User.UserPasswordLength));
var user = new UserDto()
{
Email = email,
Password = password
};
var existUser = await server.Service.AutenticateUserAsync(user);
if (!existUser)
{
ProtocolHelpers.SendResponseCommand(ProtocolConstants.ResponseCommands.Error, client.StreamCommunication);
client.StreamCommunication.Write(ConversionHandler.ConvertStringToBytes("Invalid User", ProtocolConstants.ResponseMessageLength));
}
else
{
client.User = new User()
{
Email = email,
Password = password
};
loggerService.SendMessages("Login Successfully, mail: " + email);
ProtocolHelpers.SendResponseCommand(ProtocolConstants.ResponseCommands.Ok, client.StreamCommunication);
client.StreamCommunication.Write(ConversionHandler.ConvertStringToBytes("Login Successfully", ProtocolConstants.ResponseMessageLength));
}
return(existUser);
}
public static async Task HandleUploadPhoto(Server server, CommunicationClient client)
{
var name = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(Photo.PhotoNameLength));
var extension = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(Photo.PhotoExtensionLength));
var fileSize = ConversionHandler.ConvertBytesToLong(await client.StreamCommunication.ReadAsync(ProtocolConstants.LongTypeLength));
if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(extension))
{
ProtocolHelpers.SendMessageCommand(ProtocolConstants.ResponseCommands.Ok, client, "Input Error");
}
var photo = new PhotoDto()
{
Name = name,
Extension = extension,
FileSize = fileSize,
UserEmail = client.User.Email
};
await server.Service.UploadPhotoAsync(photo);
var fileName = $"{PhotosPath}\\Image_{photo.Id}{extension}";
await FileHandler.ReceiveFileWithStreams(fileSize, fileName, client.StreamCommunication);
loggerService.SendMessages("Image uploaded");
ProtocolHelpers.SendMessageCommand(ProtocolConstants.ResponseCommands.Ok, client, "Added succesfully");
}
public static async Task <List <User> > HandleViewUsers(Client client)
{
ProtocolHelpers.SendRequestCommand(ProtocolConstants.RequestCommands.VIEW_USERS, client.StreamCommunication);
ConversionHandler.ConvertBytesToShort(await client.StreamCommunication.ReadAsync(ProtocolConstants.ShortTypeLength));
ConversionHandler.ConvertBytesToShort(await client.StreamCommunication.ReadAsync(ProtocolConstants.ShortTypeLength));
var data = await client.StreamCommunication.ReadAsync(ProtocolConstants.IntegerTypeLength);
var dataLength = ConversionHandler.ConvertBytesToInt(data);
var result = new List <User>();
while (dataLength != 0)
{
var name = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(User.UserNameLength));
var email = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(User.UserEmailLength));
var lastConnectionDate = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(ProtocolConstants.DateTimeTypeLength));
dataLength -= User.UserNameLength + User.UserEmailLength + ProtocolConstants.DateTimeTypeLength;
result.Add(new User
{
Name = name,
Email = email,
//LastConnection = DateTime.Parse(lastConnectionDate)
});
}
return(result);
}
// Advanced example
public static void ToCellsAdvance()
{
// Setup Conversion configuration
var conversionConfig = new ConversionConfig {
StoragePath = storagePath, CachePath = cachePath
};
conversionConfig.SetUseCache(true);
//instantiating the conversion handler
var conversionHandler = new ConversionHandler(conversionConfig);
//Set password to unprotect protected document during loading
LoadOptions loadOptions = new LoadOptions {
Password = "******"
};
// convert file to Xls, starting from page 2 and convert 2 pages
SaveOptions saveOptions = new CellsSaveOptions
{
ConvertFileType = CellsSaveOptions.CellsFileType.Xls,
PageNumber = 2,
NumPagesToConvert = 2
};
var convertedDocumentStream = conversionHandler.Convert <Stream>(inputGUIDFile, loadOptions, saveOptions);
}
private async Task GetData(CommunicationClient client)
{
var logged = false;
while (!logged)
{
var request = ConversionHandler.ConvertBytesToShort(await client.StreamCommunication.ReadAsync(ProtocolConstants.ShortTypeLength));
var commandType = ConversionHandler.ConvertBytesToShort(await client.StreamCommunication.ReadAsync(ProtocolConstants.ShortTypeLength));
if (commandType == (short)ProtocolConstants.RequestCommands.LOGIN)
{
logged = await ClientHandler.ValidateLogin(this, client);
}
else
{
logged = await ClientHandler.HandleCreateUser(this, client);
}
}
var gettingData = true;
while (gettingData)
{
await ProcessCommands(client);
}
}
static void Main(string[] args)
{
var storagePath = Path.Combine(RootFolder, "TestFiles");
// Set license
License license = new License();
license.SetLicense("");
// Setup Conversion configuration
var conversionConfig = new ConversionConfig
{
StoragePath = storagePath,
OutputPath = ResultPath,
UseCache = false
};
var inputDataHandler = new GoogleInputHandler(conversionConfig);
var conversionHandler = new ConversionHandler(conversionConfig, inputDataHandler);
var resultStream = conversionHandler.Convert <Stream>("document.gdoc", new WordsSaveOptions());
WriteStreamToFile(resultStream, "result.docx");
resultStream.Dispose();
Console.WriteLine("The conversion finished. Press <<ENTER>> to exit.");
Console.ReadLine();
}
public static async Task <List <Comment> > HandleViewComments(Client client, Photo photo)
{
ProtocolHelpers.SendRequestCommand(ProtocolConstants.RequestCommands.VIEW_COMMENTS, client.StreamCommunication);
client.StreamCommunication.Write(ConversionHandler.ConvertLongToBytes(photo.Id));
ConversionHandler.ConvertBytesToShort(await client.StreamCommunication.ReadAsync(ProtocolConstants.ShortTypeLength));
ConversionHandler.ConvertBytesToShort(await client.StreamCommunication.ReadAsync(ProtocolConstants.ShortTypeLength));
var data = await client.StreamCommunication.ReadAsync(ProtocolConstants.IntegerTypeLength);
var dataLength = ConversionHandler.ConvertBytesToInt(data);
var result = new List <Comment>();
while (dataLength != 0)
{
var name = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(User.UserNameLength));
var email = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(User.UserEmailLength));
var message = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(Comment.CommentLength));
dataLength -= User.UserNameLength + User.UserEmailLength + Comment.CommentLength;
result.Add(new Comment()
{
Commentator = new User
{
Email = email,
Name = name
},
Message = message,
});
}
return(result);
}
public static async Task <MessageResponse> HandleImageUpload(Client client, string filePath)
{
if (!FileHandler.FileExists(filePath))
{
return new MessageResponse()
{
responseCommands = ProtocolConstants.ResponseCommands.Error,
Message = "Invalid File",
}
}
;
var nameData = ConversionHandler.ConvertStringToBytes(FileHandler.FileName(filePath), Photo.PhotoNameLength);
var extensionData = ConversionHandler.ConvertStringToBytes(FileHandler.FileExtension(filePath), Photo.PhotoExtensionLength);
var fileSize = FileHandler.GetFileSize(filePath);
var fileSizeData = ConversionHandler.ConvertLongToBytes(fileSize);
ProtocolHelpers.SendRequestCommand(ProtocolConstants.RequestCommands.UPLOAD_PHOTO, client.StreamCommunication);
client.StreamCommunication.Write(nameData);
client.StreamCommunication.Write(extensionData);
client.StreamCommunication.Write(fileSizeData);
FileHandler.SendFileWithStream(fileSize, filePath, client.StreamCommunication);
return(await ProtocolHelpers.RecieveMessageCommand(client.StreamCommunication));
}
public ConversionApplicationBuilder Handler(ConversionHandler handler, Action <ConversionFilterBuilder> options)
{
var f = new ConversionFilterBuilder();
options(f);
f.Build().ForEach(x => handler.Filters.Add(x));
handlers.Add(handler);
return(this);
}
public void Setup()
{
_arabicToRomanConverter = new Mock <IArabicToRomanConverter>();
_arabicToRomanConverter.Setup(_ => _.ArabicToRoman(4));
_romanToArabicConverter = new Mock <IRomanToArabicConverter>();
_romanToArabicConverter.Setup(_ => _.RomanToArabic("IV"));
_conversionHandler = new ConversionHandler(_arabicToRomanConverter.Object, _romanToArabicConverter.Object);
}
// Result as Stream
public static void ToCellsAsStream()
{
// Setup Conversion configuration
var conversionConfig = new ConversionConfig {
StoragePath = storagePath, CachePath = cachePath
};
//instantiating the conversion handler
var conversionHandler = new ConversionHandler(conversionConfig);
var convertedDocumentStream = conversionHandler.Convert <Stream>(inputGUIDFile, new CellsSaveOptions());
}
public static async Task <MessageResponse> HandleLogin(Client client, User user)
{
ProtocolHelpers.SendRequestCommand(ProtocolConstants.RequestCommands.LOGIN, client.StreamCommunication);
var email = ConversionHandler.ConvertStringToBytes(user.Email, User.UserEmailLength);
var password = ConversionHandler.ConvertStringToBytes(user.Password, User.UserPasswordLength);
client.StreamCommunication.Write(email);
client.StreamCommunication.Write(password);
return(await ProtocolHelpers.RecieveMessageCommand(client.StreamCommunication));
}
public static async Task <MessageResponse> HandleCommentCreation(Client client, Comment comment)
{
ProtocolHelpers.SendRequestCommand(ProtocolConstants.RequestCommands.COMMENT_PHOTO, client.StreamCommunication);
var photoIdData = ConversionHandler.ConvertLongToBytes(comment.Photo.Id);
var commentData = ConversionHandler.ConvertStringToBytes(comment.Message, Comment.CommentLength);
client.StreamCommunication.Write(photoIdData);
client.StreamCommunication.Write(commentData);
return(await ProtocolHelpers.RecieveMessageCommand(client.StreamCommunication));
}
//public static string inputGUIDFile = "Slidessample.Pdf";
// Result as file path
public static void ToSlidesAsPath()
{
// Setup Conversion configuration
var conversionConfig = new ConversionConfig {
StoragePath = storagePath, CachePath = cachePath
};
//instantiating the conversion handler
var conversionHandler = new ConversionHandler(conversionConfig);
var convertedDocumentPath = conversionHandler.Convert <string>(inputGUIDFile, new SlidesSaveOptions());
}
/// <summary>
/// Writes a generic value to a byte array.
/// </summary>
/// <param name="data">Binary data stream, in which should be written.</param>
/// <param name="value">Value that should be seralized and written to the binary stream.</param>
/// <param name="index">Byte position of the values within the array.</param>
public virtual void SetValue <T>(byte[] data, T value, int index)
{
ConversionHandler <T> converter = _genericHandlers[typeof(T)] as ConversionHandler <T>;
if (converter != null)
{
converter.SetMethod(data, value, index);
}
else
{
throw new ArgumentException();
}
}
public override bool UseItem(Player player)
{
if (flag)
{
ConversionHandler.ConvertDown((int)(player.Center.X / 16f), (int)(player.Bottom.Y / 16f) + 3, 40, ConversionType.INFERNO);
}
else
{
ConversionHandler.ConvertDown((int)(player.Center.X / 16f), (int)(player.Bottom.Y / 16f) + 3, 40, ConversionType.MIRE);
}
flag = false;
return(true);
}
//public static string inputGUIDFile = "PDFsample.pdf";
// Result as file path
public static void ToImageAsPath()
{
// Setup Conversion configuration
var conversionConfig = new ConversionConfig {
StoragePath = storagePath, CachePath = cachePath
};
//instantiating the conversion handler
var conversionHandler = new ConversionHandler(conversionConfig);
var convertedDocumentPath = conversionHandler.Convert <IList <string> >(inputGUIDFile, new ImageSaveOptions {
ConvertFileType = ImageSaveOptions.ImageFileType.Jpg
});
}
public void Setup()
{
_arabicToRomanConverter = new Mock <IArabicToRomanConverter>()
{
CallBase = true
};
_arabicToRomanConverter.Setup(_ => _.ArabicToRoman(70)).Returns("CXX");
_romanToArabicConverter = new Mock <IRomanToArabicConverter>()
{
CallBase = true
};
_romanToArabicConverter.Setup(_ => _.RomanToArabic("CXX")).Returns(70);
_conversionHandler = new ConversionHandler(_arabicToRomanConverter.Object, _romanToArabicConverter.Object);
}
public static async Task <MessageResponse> HandleRegister(Client client, User user)
{
ProtocolHelpers.SendRequestCommand(ProtocolConstants.RequestCommands.CREATE_USER, client.StreamCommunication);
var name = ConversionHandler.ConvertStringToBytes(user.Name, User.UserNameLength);
var email = ConversionHandler.ConvertStringToBytes(user.Email, User.UserEmailLength);
var password = ConversionHandler.ConvertStringToBytes(user.Password, User.UserPasswordLength);
client.StreamCommunication.Write(email);
client.StreamCommunication.Write(name);
client.StreamCommunication.Write(password);
var response = await ProtocolHelpers.RecieveMessageCommand(client.StreamCommunication);
return(response);
}
protected void lnkbtn_Convert_OnClick(object sender, EventArgs e)
{
/*
* CONVERT ALL THE FILES TO PDF FORMAT & STORE IN OUTPUT_DIRECTORY
*/
foreach (ListItem files in lst_SourceFiles.Items)
{
//SET UPLOAD FOLDER
filePath = Server.MapPath("~/Uploads/");
//SET CACHE FOLDER WHERE THE CONVERSION TEMPORARY FILES ARE RUNNING
cachePath = Server.MapPath("~/Cache/");
//SET OUTPUT FOLDER WHERE THE ACTUAL FILES WILL BE PLACED AFTER CONVERSION
outputPath = Server.MapPath("~/OutputDir/");
//ORIGINAL FILE NAME WITH EXTENSION e.g SAMPLEFILE1.DOC
string file = files.Text;
//CONVERSION CONFIGURATION FOR DEFAULT
ConversionConfig _conConfg = new ConversionConfig
{
StoragePath = filePath,
CachePath = cachePath,
OutputPath = outputPath
};
ConversionHandler conversionHandler = new ConversionHandler(_conConfg);
//CONVERSION TO PDF VIA FILE PATH
var convertedPDF = conversionHandler.Convert <string>(file, new PdfSaveOptions
{
ConvertFileType = PdfSaveOptions.PdfFileType.Pdf,
OutputType = OutputType.String
});
}
//GETS ALL THE CONVERTED FILES FROM OUTPUT FOLDER
string[] myOutputFiles = Directory.GetFiles(outputPath);
foreach (var items in myOutputFiles)
{
lst_DestinationFiles.Items.Add(new ListItem(Path.GetFileName(items), items));
}
lbl_destinationFiles.Text = @"All " + myOutputFiles.Length + " have been successfully synced!";
}
private static void OnConvertOptionsParsed(ConvertOptions options)
{
HasParsedArgs = true;
if (!File.Exists(options.File))
{
Console.WriteLine($"The file {options.File} does not exist.");
return;
}
var fileText = ReadFile(options.File);
string amlRoot;
var outputFile = options.Output;
if (string.IsNullOrWhiteSpace(outputFile))
{
outputFile = ConstructOutputFilePath(options.File);
}
try
{
amlRoot = ConversionHandler.Convert(fileText, outputFile);
}
catch (Exception)
{
Console.WriteLine("An error occurred during conversion. The file has probably an invalid format.");
return;
}
try
{
if (!ShouldOverride(outputFile))
{
return;
}
File.WriteAllText(outputFile, amlRoot);
}
catch (IOException)
{
Console.WriteLine(
"Unable to write output file. Maybe you are missing permissions or the file is opened in another software");
return;
}
}
static void Main()
{
var storagePath = Path.Combine(RootFolder, "TestFiles");
var cachePath = Path.Combine(RootFolder, "Cache");
// Set license
License license = new License();
license.SetLicense("");
// Setup Conversion configuration
var conversionConfig = new ConversionConfig
{
StoragePath = storagePath,
OutputPath = ResultPath,
CachePath = cachePath,
UseCache = false
};
_conversionHandler = new ConversionHandler(conversionConfig);
// Convert Pdf To Html
ConvertPdfToHtml();
// Convert Doc to Pdf
ConvertDocToPdf();
// Convert Doc From Stream to PDf
ConvertDocFromStreamToPdf();
// Convert Doc to Jpg
ConvertDocToJpg();
// Convert Doc to Jpg with custom options
ConvertDocToPngWithCustomOptions();
// Convert Doc to Bmp through Pdf
ConvertDocToBmpThroughPdf();
//Convert Doc to PDF and return the path of the converted file
ConvertDocToPdfReturnPath();
Console.WriteLine("Conversion complete. Press any key to exit");
Console.ReadKey();
}
private async Task ProcessCommands(CommunicationClient client)
{
var request = ConversionHandler.ConvertBytesToShort(await client.StreamCommunication.ReadAsync(ProtocolConstants.ShortTypeLength));
var commandType = ConversionHandler.ConvertBytesToShort(await client.StreamCommunication.ReadAsync(ProtocolConstants.ShortTypeLength));
switch (commandType)
{
case (short)ProtocolConstants.RequestCommands.LOGIN:
await ClientHandler.HandleCreateUser(this, client);
break;
case (short)ProtocolConstants.RequestCommands.UPLOAD_PHOTO:
await ClientHandler.HandleUploadPhoto(this, client);
break;
case (short)ProtocolConstants.RequestCommands.VIEW_USERS:
await ClientHandler.HandleViewUsers(this, client);
break;
case (short)ProtocolConstants.RequestCommands.VIEW_PHOTOS:
await ClientHandler.HandleViewPhotos(this, client);
break;
case (short)ProtocolConstants.RequestCommands.VIEW_COMMENTS:
await ClientHandler.HandleViewCommentsPhoto(this, client);
break;
case (short)ProtocolConstants.RequestCommands.COMMENT_PHOTO:
await ClientHandler.HandleCommentPhoto(this, client);
break;
default:
ProtocolHelpers.SendResponseCommand(ProtocolConstants.ResponseCommands.Error, client.StreamCommunication);
client.StreamCommunication.Write(ConversionHandler.ConvertStringToBytes("Invalid User", ProtocolConstants.ResponseMessageLength));
break;
}
}
public static async Task <bool> HandleCreateUser(Server server, CommunicationClient client)
{
var name = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(User.UserNameLength));
var email = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(User.UserEmailLength));
var password = ConversionHandler.ConvertBytesToString(await client.StreamCommunication.ReadAsync(User.UserPasswordLength));
if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(email))
{
ProtocolHelpers.SendResponseCommand(ProtocolConstants.ResponseCommands.Error, client.StreamCommunication);
client.StreamCommunication.Write(ConversionHandler.ConvertStringToBytes("Input Error", ProtocolConstants.ResponseMessageLength));
}
var user = new UserDto()
{
Email = email,
Name = name,
Password = password,
IsLogedIn = true
};
var response = await server.Service.AddUserAsync(user);
if (response.Status.Equals("Ok"))
{
client.User = new User()
{
Email = email,
Name = name,
Password = password,
};
loggerService.SendMessages("User created, mail: " + email);
ProtocolHelpers.SendResponseCommand(ProtocolConstants.ResponseCommands.Ok, client.StreamCommunication);
client.StreamCommunication.Write(ConversionHandler.ConvertStringToBytes(response.Message, ProtocolConstants.ResponseMessageLength));
}
else
{
ProtocolHelpers.SendResponseCommand(ProtocolConstants.ResponseCommands.Error, client.StreamCommunication);
client.StreamCommunication.Write(ConversionHandler.ConvertStringToBytes(response.Message, ProtocolConstants.ResponseMessageLength));
}
return(response.Status.Equals("Ok"));
}
public override void ConvertToDatabase(ConversionHandler conversionHandler, TableSelectionHandler tableSelectionHandler, FailedViewDefinitionHandler failedViewDefinitionHandler, bool createTriggers)
{
using (sqlConnection = new SqlConnection(Connections.OtherConnection.ConnectionString))
{
try
{
sqlConnection.Open();
LoadSchema();
sqlConnection.Close();
}
catch (Exception)
{
if (sqlConnection.State == ConnectionState.Open)
{
sqlConnection.Close();
}
throw;
}
}
}
protected override void ConvertSourceDatabaseToDestination(ConversionHandler conversionHandler, TableSelectionHandler tableSelectionHandler, FailedViewDefinitionHandler failedViewDefinitionHandler, bool createTriggers)
{
throw new System.NotImplementedException();
}
protected override void CopySourceDataToDestination(ConversionHandler conversionHandler)
{
throw new System.NotImplementedException();
}
public override void ConvertToDatabase(ConversionHandler conversionHandler, TableSelectionHandler tableSelectionHandler, FailedViewDefinitionHandler failedViewDefinitionHandler, bool createTriggers)
{
base.ConvertToDatabase(conversionHandler, tableSelectionHandler, failedViewDefinitionHandler, createTriggers);
}
