public void Save()
{
//build our array
var lines = new List <string>
{
RegKey,
// Legacy key
string.Empty
};
foreach (var pair in _updateRecords
.ToList())
{
lines.Add(pair.Key.ToString());
var dateLine = pair.Value.LastChecked.Ticks.ToString(CultureInfo.InvariantCulture) + "|" +
pair.Value.ExpirationDate.Ticks.ToString(CultureInfo.InvariantCulture);
lines.Add(dateLine);
}
var licenseFile = Filename;
_fileSystem.CreateDirectory(Path.GetDirectoryName(licenseFile));
lock (_fileLock)
{
_fileSystem.WriteAllLines(licenseFile, lines);
}
}
public int TrackPublicationChangesOnCDS()
{
var resultFlag = -1;
try {
string pubUpdateFileCDSPath = CommonCalls.PubUpdateFileCDSPath;
string pubUpdateFileLocalPath = CommonCalls.PubUpdateFileLocalPath;
if (File.Exists(pubUpdateFileCDSPath))
{
File.Copy(pubUpdateFileCDSPath, pubUpdateFileLocalPath, true);
}
if (File.Exists(pubUpdateFileLocalPath))
{
string[] pubRecords = File.ReadAllLines(pubUpdateFileLocalPath);
var pubRecordsExceptToday = pubRecords.Where(p => !p.Trim().EndsWith(DateTime.Now.ToString("dd/MM/yy"))).ToList();
resultFlag = diskDeliveryDAO.TrackPublicationChangesOnCDS(pubRecordsExceptToday);
File.WriteAllText(pubUpdateFileLocalPath, string.Empty);
string[] pubRecordsCDS = File.ReadAllLines(pubUpdateFileCDSPath);
var pubRecordsTodayCDS = pubRecordsCDS.Where(p => p.Trim().EndsWith(DateTime.Now.ToString("dd/MM/yy"))).ToList();
File.WriteAllLines(pubUpdateFileCDSPath, pubRecordsTodayCDS);
}
return(resultFlag);
} catch (Exception) {
return(-1);
}
}
public async Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
List <string> lines = new();
foreach (var path in Directory.GetDirectories(request.Directory))
{
var files = Directory.GetFiles(path);
var fileNames = Directory.GetFiles(path)
.Select(path => Path.GetFileNameWithoutExtension(path));
var containsIndex = Directory.GetFiles(path)
.Select(path => Path.GetFileNameWithoutExtension(path))
.Contains("index");
if (Directory.GetFiles(path)
.Select(path => Path.GetFileNameWithoutExtension(path))
.Contains("index"))
{
lines.Add($"export * from './{Path.GetFileNameWithoutExtension(path)}';");
}
}
foreach (var file in Directory.GetFiles(request.Directory, "*.ts"))
{
if (!file.Contains(".spec.") && !file.EndsWith("index.ts"))
{
lines.Add($"export * from './{Path.GetFileNameWithoutExtension(file)}';");
}
}
_fileSystem.WriteAllLines($"{request.Directory}{Path.DirectorySeparatorChar}index.ts", lines.ToArray());
return(new());
}
public async Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
var template = _templateLocator.Get("EntityServiceBuilder");
var tokens = new TokensBuilder()
.With(nameof(request.EntityName), (Token)request.EntityName)
.With(nameof(request.Directory), (Token)request.Directory)
.Build();
var result = _templateProcessor.Process(template, tokens);
var entityNameSnakeCase = _templateProcessor.Process("{{ entityNameSnakeCase }}", tokens);
var filename = $"{entityNameSnakeCase}.service.ts";
if (_fileSystem.Exists($@"{request.Directory}/{filename}"))
{
if (request.Force)
{
System.IO.File.Delete($@"{request.Directory}/{filename}");
System.IO.File.Delete($@"{request.Directory}/{entityNameSnakeCase}.service.spec.ts");
}
else
{
return(new());
}
}
_commandService.Start($"ng g s {entityNameSnakeCase}", request.Directory);
_fileSystem.WriteAllLines($@"{request.Directory}/{filename}", result);
return(new());
}
public void Save(IReadOnlyList <string> commands)
{
if (commands == null)
{
throw new ArgumentNullException(nameof(commands));
}
_fileSystem.WriteAllLines(_options.FilePath, commands, _options.Encoding);
}
private void WriteAllLines(string filePath, IEnumerable <string> lines)
{
try
{
_fileSystem.WriteAllLines(filePath, lines);
}
catch (Exception ex)
{
throw new GitModelException($"Unable to write commit file to: {filePath}. Refer to the inner exception for details.", ex);
}
}
public void Adjust(string slnFile, Guid projectGuid)
{
var projectGuidStr = projectGuid.ToString("D").ToUpper();
var lines = _fileSystem.ReadAllLines(slnFile)
.Select(
l => l.Contains(CSProjTypeGuid) && l.Contains(projectGuidStr)
? l.Replace(CSProjTypeGuid, XProjTypeGuid).Replace("csproj", "xproj")
: l
);
_fileSystem.WriteAllLines(slnFile, lines);
}
public async Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
var template = _templateLocator.Get(nameof(IntlBuilder));
var tokens = new TokensBuilder()
.With(nameof(request.Name), (Token)request.Name)
.Build();
var lines = _templateProcessor.Process(template, tokens);
_fileSystem.WriteAllLines($"{request.Directory}{Path.DirectorySeparatorChar}{((Token)request.Name).SnakeCase}-intl.ts", lines);
return(new());
}
public Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
Settings settings = _settingsProvider.Get(request.Directory);
var tokens = new TokensBuilder()
.With(nameof(request.EntityName), (Token)request.EntityName)
.With(nameof(request.Directory), (Token)request.Directory)
.Build();
var result = new List <string>()
{
_templateProcessor.Process("export type {{ entityNamePascalCase }} = {", tokens)
};
var modelsDirectory = $"{settings.DomainDirectory}{Path.DirectorySeparatorChar}Models";
foreach (var path in Directory.GetFiles(modelsDirectory, $"{((Token)request.EntityName).PascalCase}.cs", SearchOption.AllDirectories))
{
foreach (var line in File.ReadAllLines(path))
{
if (line.Contains("public string") || line.Contains("public Guid"))
{
result.Add($" {_namingConventionConverter.Convert(NamingConvention.CamelCase, line.Split(' ')[10])}: string,");
}
if (line.Contains("public int") || line.Contains("public double"))
{
result.Add($" {_namingConventionConverter.Convert(NamingConvention.CamelCase, line.Split(' ')[10])}: number,");
}
if (line.Contains("public bool"))
{
result.Add($" {_namingConventionConverter.Convert(NamingConvention.CamelCase, line.Split(' ')[10])}: boolean,");
}
}
}
result.Add("};");
var filePath = _templateProcessor.Process("{{ directory }}//{{ entityNameSnakeCase }}.ts", tokens);
if (System.IO.File.Exists(filePath) && request.Force == false)
{
return(Task.FromResult(new Unit()));
}
_fileWriter.WriteAllLines(filePath, result.ToArray());
return(Task.FromResult(new Unit()));
}
// }
public bool SaveListOfUsers(string filePath)
{
var allUsers = _userRepository.GetAllUsers();
var exportData = string.Join(Environment.NewLine, allUsers.Select(user => $"{user.FirstName} {user.LastName}"));
if (_fileSystem.FileExists(filePath))
{
_fileSystem.Delete(filePath);
}
_fileSystem.WriteAllLines(filePath, exportData);
return(true);
}
public void RunTaskOnNextStartup(string key)
{
var path = Path.Combine(ApplicationPaths.CachePath, "startuptasks.txt");
List <string> lines;
try
{
lines = _fileSystem.ReadAllLines(path).ToList();
}
catch
{
lines = new List <string>();
}
if (!lines.Contains(key, StringComparer.OrdinalIgnoreCase))
{
lines.Add(key);
_fileSystem.CreateDirectory(_fileSystem.GetDirectoryName(path));
_fileSystem.WriteAllLines(path, lines);
}
}
public void HandleRequest(IZoneRequest request)
{
var definition = request.Data.GetOrDefault <int>(k.definition);
var ed = EntityDefault.Get(definition);
ed.Equals(EntityDefault.None).ThrowIfTrue(ErrorCodes.ItemNotFound);
var units = _zone.Units.Where(u => u.ED.Definition == definition).ToArray();
var linez = new List <string>();
foreach (var unit in units)
{
var ux = unit.CurrentPosition.intX;
var uy = unit.CurrentPosition.intY;
linez.Add("gotoxy " + ux + " " + uy);
}
_fileSystem.WriteAllLines("gotoxy_" + ed.Name + "_z" + _zone.Id + "_.txt", linez);
Message.Builder.FromRequest(request).WithOk().Send();
}
public void WriteAllLines(FileInfo file, IEnumerable <string> lines)
{
_fileSystem.WriteAllLines(file, lines);
}
public void WriteAllLines(NPath path, string[] contents)
{
fileSystem.WriteAllLines(path.ToProcessDirectory().ToString(), contents);
}
/// <summary>
/// Executes the changes recorded for the associated file in chronological order.
/// </summary>
public override void ExecuteChanges(IFileSystem fileSystem)
{
string newPath;
if (fileSystem.IsDirectory(AssociatedPath) && _newName != null)
{
string tmp = AssociatedPath.Substring(0, AssociatedPath.Length - FileSystem.PathSeparator.Length);
newPath = "\\" + tmp.Substring(0, tmp.LastIndexOf("\\")) + "\\" + _newName;
newPath = newPath.Replace("\\\\", "\\");
fileSystem.Move(AssociatedPath, newPath);
return;
}
String[] fileContent = fileSystem.ReadAllLines(AssociatedPath);
IList<String> updatedFileContent = new List<String>();
if (_newName != null)
{
newPath = AssociatedPath.Substring(0, AssociatedPath.LastIndexOf("\\")) + "\\" + _newName;
newPath = newPath.Replace("\\\\", "\\");
fileSystem.Move(AssociatedPath, newPath);
}
else
{
newPath = AssociatedPath;
}
if (_modificationList.Count > 0)
{
int contentPointer = 0;
foreach (AbstractModification modification in _modificationList)
{
for (; contentPointer < modification.LineNumber && contentPointer < fileContent.Length; contentPointer++)
{
updatedFileContent.Add(fileContent[contentPointer]);
}
if (modification is DeletionModification)
{
if (modification.LineNumber != contentPointer)
Debug.WriteLine("modification.LineNumber != contentPointer => " + modification.LineNumber + ", " +
contentPointer);
contentPointer++;
}
else if (modification is InsertionModification)
{
InsertionModification insertion = modification as InsertionModification;
updatedFileContent.Add(insertion.Line);
}
}
fileContent = updatedFileContent.ToArray();
}
fileSystem.WriteAllLines(newPath, fileContent);
}
/// <summary>
/// Executes the creation of the file.
/// </summary>
/// <exception cref="System.Exception">To bad, u f*cked up</exception>
public void ExecuteCreation(IFileSystem fileSystem)
{
fileSystem.WriteAllLines(_associatedPath, _content);
}
