/// <summary>
/// Writes the specified record.
/// </summary>
/// <param name="record">The record.</param>
/// <exception cref="ArgumentNullException">Throws when record is null.</exception>
public void Write(FileCabinetRecord record)
{
if (record is null)
{
throw new ArgumentNullException($"{nameof(record)} must not be null");
}
var doc = new XmlDocument();
this.writer.BaseStream.Position = 0;
doc.Load(this.writer.BaseStream);
var root = doc.DocumentElement;
var fileRecordNode = doc.CreateElement("FileCabinetRecord");
AddChild("Id", record.Id.ToString(CultureInfo.InvariantCulture), fileRecordNode, doc);
AddChild("FirstName", record.FirstName, fileRecordNode, doc);
AddChild("LastName", record.LastName, fileRecordNode, doc);
AddChild("DateOfBirth", record.DateOfBirth.ToString("o", CultureInfo.InvariantCulture), fileRecordNode, doc);
AddChild("Department", record.Department.ToString(CultureInfo.InvariantCulture), fileRecordNode, doc);
AddChild("Salary", record.Salary.ToString(CultureInfo.InvariantCulture), fileRecordNode, doc);
AddChild("Class", ((int)record.Class).ToString(CultureInfo.InvariantCulture), fileRecordNode, doc);
root.AppendChild(fileRecordNode);
this.writer.BaseStream.Position = 0;
doc.Save(this.writer.BaseStream);
}
/// <summary>
/// Сonverts an array of bytes to a single record.
/// </summary>
/// <param name="bytes">Input bytes.</param>
/// <returns>Record.</returns>
public static FileCabinetRecord ToFileCabinetRecord(this byte[] bytes)
{
if (bytes == null)
{
throw new ArgumentNullException(nameof(bytes));
}
using (var memoryStream = new MemoryStream(bytes))
{
using (var binaryReader = new BinaryReader(memoryStream))
{
binaryReader.BaseStream.Position = 0;
FileCabinetRecord record = new FileCabinetRecord();
status = binaryReader.ReadInt16();
record.Id = binaryReader.ReadInt32();
var firstNameBuffer = binaryReader.ReadBytes(maxStringLength);
var lastNameBuffer = binaryReader.ReadBytes(maxStringLength);
var firstNameLength = Encoding.ASCII.GetString(firstNameBuffer, 0, firstNameBuffer.Length);
var lastNameLength = Encoding.ASCII.GetString(lastNameBuffer, 0, lastNameBuffer.Length);
record.FirstName = firstNameLength.Replace("\0", string.Empty, StringComparison.OrdinalIgnoreCase);
record.LastName = lastNameLength.Replace("\0", string.Empty, StringComparison.OrdinalIgnoreCase);
var yearOfBirth = binaryReader.ReadInt32();
var monthOfBirth = binaryReader.ReadInt32();
var dayOfBirth = binaryReader.ReadInt32();
record.DateOfBirth = new DateTime(yearOfBirth, monthOfBirth, dayOfBirth);
record.Age = binaryReader.ReadInt16();
record.Salary = binaryReader.ReadDecimal();
record.Gender = binaryReader.ReadChar();
return(record);
}
}
}
/// <inheritdoc/>
public bool Insert(FileCabinetRecord record)
{
if (record is null)
{
throw new ArgumentNullException(nameof(record));
}
if (!this.recordValidator.ValidateParameters(record).Item1)
{
Console.WriteLine(this.recordValidator.ValidateParameters(record).Item2);
return(false);
}
if (this.idсache.ContainsKey(record.Id))
{
this.fileReader.BaseStream.Seek(this.idсache[record.Id], 0);
if (!this.fileReader.ReadBoolean())
{
Console.WriteLine(Source.Resource.GetString("idAlreadyExists", CultureInfo.InvariantCulture));
return(false);
}
this.WriteToFile(record, this.offset);
this.offset += RecordSize;
return(true);
}
this.WriteToFile(record, this.offset);
this.idсache.Add(record.Id, this.offset);
this.offset += RecordSize;
return(true);
}
private static byte[] FileCabinetRecordToBytes(FileCabinetRecord fileCabinetRecord)
{
if (fileCabinetRecord == null)
{
throw new ArgumentNullException(nameof(fileCabinetRecord));
}
var bytes = new byte[RecordSize];
using (var memoryStream = new MemoryStream(bytes))
using (var binaryWriter = new BinaryWriter(memoryStream))
{
short status = 0;
binaryWriter.Write(status);
binaryWriter.Write(fileCabinetRecord.Id);
binaryWriter.Write(fileCabinetRecord.FirstName.PadRight(MaximumLengthOfFirstAndLastName));
binaryWriter.Write(fileCabinetRecord.LastName.PadRight(MaximumLengthOfFirstAndLastName));
binaryWriter.Write(fileCabinetRecord.DateOfBirth.Year);
binaryWriter.Write(fileCabinetRecord.DateOfBirth.Month);
binaryWriter.Write(fileCabinetRecord.DateOfBirth.Day);
binaryWriter.Write(fileCabinetRecord.Wallet);
binaryWriter.Write(fileCabinetRecord.MaritalStatus);
binaryWriter.Write(fileCabinetRecord.Height);
}
return(bytes);
}
/// <summary>
/// Validates favourite character of user's input.
/// </summary>
/// <param name="record">Record to validate.</param>
/// <returns>Exception message.</returns>
public string Validate(FileCabinetRecord record)
{
if (record == null)
{
throw new ArgumentNullException($"Record is invalid.");
}
if (!char.IsLetter(record.FavouriteCharacter))
{
return("Favourite character is invalid. Should be letter.");
}
switch (this.symbolCase)
{
case -1:
if (char.IsUpper(record.FavouriteCharacter))
{
return("Favourite character is invalid. Should be lowercase.");
}
break;
case 1:
if (char.IsLower(record.FavouriteCharacter))
{
return("Favourite character is invalid. Should be uppercase.");
}
break;
}
return(null);
}
/// <inheritdoc/>
public void EditRecord(int id, FileCabinetRecord recordParameters)
{
if (id < 0)
{
throw new ArgumentException($"The {nameof(id)} cannot be less than zero.");
}
if (recordParameters == null)
{
throw new ArgumentNullException(nameof(recordParameters));
}
recordParameters.Id = id;
this.validator.ValidateParameters(recordParameters);
if (this.identifierDictionary.ContainsKey(recordParameters.Id))
{
var recordForRemoveFromDictionaries = new FileCabinetRecord();
this.TryGetRecordWithId(recordParameters.Id, ref recordForRemoveFromDictionaries);
this.RemoveEntryFromDictionaries(recordForRemoveFromDictionaries, this.identifierDictionary[recordParameters.Id]);
var bytesOfRecordParameters = FileCabinetRecordToBytes(recordParameters);
this.fileStream.Seek(this.identifierDictionary[recordParameters.Id], SeekOrigin.Begin);
this.AddEntryToDictionaries(recordParameters, this.fileStream.Position);
this.fileStream.Write(bytesOfRecordParameters, 0, bytesOfRecordParameters.Length);
this.fileStream.Flush();
}
else
{
throw new ArgumentException($"#{id} record is not found.", nameof(id));
}
}
/// <inheritdoc/>
public int Insert(FileCabinetRecord fileCabinetRecord)
{
if (fileCabinetRecord == null)
{
throw new ArgumentNullException(nameof(fileCabinetRecord));
}
this.validator.ValidateParameters(fileCabinetRecord);
if (fileCabinetRecord.Id > 0)
{
if (!this.identifierDictionary.ContainsKey(fileCabinetRecord.Id))
{
return(this.CreateRecord(fileCabinetRecord, true));
}
else
{
throw new ArgumentException("A record with the given ID already exists.", nameof(fileCabinetRecord));
}
}
else
{
return(this.CreateRecord(fileCabinetRecord));
}
}
/// <inheritdoc/>
public int CreateRecord(FileCabinetRecord recordParameters, bool useId = false)
{
if (recordParameters == null)
{
throw new ArgumentNullException(nameof(recordParameters));
}
if (recordParameters.Id < 0)
{
throw new ArgumentException("The record ID must be greater than zero.", nameof(recordParameters));
}
this.validator.ValidateParameters(recordParameters);
if (!useId)
{
recordParameters.Id = ++this.lastRecordId;
}
var bytesOfNewRecord = FileCabinetRecordToBytes(recordParameters);
this.fileStream.Seek(0, SeekOrigin.End);
this.AddEntryToDictionaries(recordParameters, this.fileStream.Position);
this.fileStream.Write(bytesOfNewRecord, 0, bytesOfNewRecord.Length);
this.fileStream.Flush();
this.UpdateLastRecordId();
return(recordParameters.Id);
}
private FileCabinetRecord GetRecord(int offset)
{
offset += ShortSize;
this.fileReader.BaseStream.Seek(offset, 0);
var tempRecord = new FileCabinetRecord();
tempRecord.Id = this.fileReader.ReadInt32();
offset += IntSize;
tempRecord.FirstName = this.fileReader.ReadString();
this.fileReader.BaseStream.Seek(offset + StringSize, 0);
tempRecord.LastName = this.fileReader.ReadString();
offset += StringSize;
this.fileReader.BaseStream.Seek(offset + StringSize, 0);
int day = this.fileReader.ReadInt32();
int month = this.fileReader.ReadInt32();
int year = this.fileReader.ReadInt32();
tempRecord.DateOfBirth = tempRecord.DateOfBirth.AddDays(day - 1);
tempRecord.DateOfBirth = tempRecord.DateOfBirth.AddMonths(month - 1);
tempRecord.DateOfBirth = tempRecord.DateOfBirth.AddYears(year - 1);
tempRecord.Sex = this.fileReader.ReadChar();
tempRecord.Weight = this.fileReader.ReadDecimal();
tempRecord.Height = this.fileReader.ReadInt16();
return(tempRecord);
}
private void Insert(string parameters)
{
var(properties, values) = this.Parse(parameters);
var recordPropertyInfo = typeof(FileCabinetRecord).GetProperties();
var record = new FileCabinetRecord()
{
FirstName = this.GeneRateName(),
LastName = this.GeneRateName(),
DateOfBirth = this.GenerateDateOfBirth(),
Gender = this.GenerateGender(),
Account = this.randomGenerator.Next(),
Experience = Convert.ToInt16(this.randomGenerator.Next(DateTime.Now.Year - this.GenerateDateOfBirth().Year)),
};
for (int i = 0; i < properties.Length; i++)
{
var recordProperty = recordPropertyInfo.FirstOrDefault(prop => string.Equals(prop.Name, properties[i], StringComparison.OrdinalIgnoreCase));
if (recordProperty is null)
{
continue;
}
var converter = TypeDescriptor.GetConverter(recordProperty.PropertyType);
recordProperty.SetValue(record, converter.ConvertFromInvariantString(values[i]));
}
var data = new FileCabinetInputData(record.FirstName, record.LastName, record.DateOfBirth, record.Gender, record.Experience, record.Account);
this.fileCabinetService.CreateRecord(data);
}
/// <summary>
/// Validates the parameters.
/// </summary>
/// <param name="record">The record.</param>
public void ValidateParameters(FileCabinetRecord record)
{
foreach (var validator in this.validators)
{
validator.ValidateParameters(record);
}
}
/// <summary>
/// Removes a record from the list by given id.
/// </summary>
/// <param name="id">Id to remove record by.</param>
/// <returns>Id of removed record if succeeded, -1 otherwise.
/// </returns>
public int RemoveRecord(int id)
{
int offset = this.recordIdOffset[id];
if (offset == -1)
{
return(-1);
}
FileCabinetRecord prevRecord = this.ReadRecord(offset);
this.DeleteOffsets(prevRecord, offset);
ushort numToAdd = 4;
byte[] reservedBytes = new byte[2];
this.fileStream.Seek(offset, SeekOrigin.Begin);
this.fileStream.Read(reservedBytes, 0, 2);
reservedBytes = BitConverter.GetBytes((ushort)(BitConverter.ToUInt16(reservedBytes) | numToAdd));
this.fileStream.Seek(offset, SeekOrigin.Begin);
this.fileStream.Write(reservedBytes, 0, 2);
this.idlist.Remove(id);
this.deleted++;
return(id);
}
/// <inheritdoc/>
public int Insert(FileCabinetRecord fileCabinetRecord)
{
if (fileCabinetRecord == null)
{
throw new ArgumentNullException(nameof(fileCabinetRecord));
}
this.validator.ValidateParameters(fileCabinetRecord);
if (fileCabinetRecord.Id > 0)
{
var recordsWithThisId = this.list.Where(record => record.Id == fileCabinetRecord.Id).ToList();
if (recordsWithThisId.Count == 0)
{
var insertedRecordId = this.CreateRecord(fileCabinetRecord, true);
this.UpdateLastRecordId();
return(insertedRecordId);
}
else
{
throw new ArgumentException("A record with the given ID already exists.", nameof(fileCabinetRecord));
}
}
else
{
return(this.CreateRecord(fileCabinetRecord));
}
}
/// <inheritdoc/>
public int CreateRecord(FileCabinetRecord recordParameters, bool useId = false)
{
if (recordParameters == null)
{
throw new ArgumentNullException(nameof(recordParameters));
}
if (recordParameters.Id < 0)
{
throw new ArgumentException("The record ID must be greater than zero.", nameof(recordParameters));
}
this.validator.ValidateParameters(recordParameters);
if (!useId)
{
recordParameters.Id = ++this.lastRecordId;
}
this.list.Add(recordParameters);
this.AddEntryToDictionaries(recordParameters);
this.UpdateLastRecordId();
return(recordParameters.Id);
}
/// <inheritdoc/>
public Tuple <bool, string> ValidateParameters(FileCabinetRecord recordParameters)
{
if (recordParameters == null)
{
throw new ArgumentNullException(nameof(recordParameters));
}
var validationResults = new List <Tuple <bool, string> >();
validationResults.Add(this.IdentifierValidator(recordParameters.Id));
validationResults.Add(this.FirstNameValidator(recordParameters.FirstName));
validationResults.Add(this.LastNameValidator(recordParameters.LastName));
validationResults.Add(this.DateOfBirthValidator(recordParameters.DateOfBirth));
validationResults.Add(this.WalletValidator(recordParameters.Wallet));
validationResults.Add(this.MaritalStatusValidator(recordParameters.MaritalStatus));
validationResults.Add(this.HeightValidator(recordParameters.Height));
bool validationResult = true;
StringBuilder errorMessages = new StringBuilder();
foreach (var result in validationResults)
{
validationResult = validationResult && result.Item1;
if (!result.Item1)
{
errorMessages.Append(" " + result.Item2);
}
}
return(new Tuple <bool, string>(validationResult, errorMessages.ToString()));
}
/// <inheritdoc/>
public void ValidateParameters(FileCabinetRecord record)
{
if (!record.Sex.IsClassicGender())
{
throw new ArgumentException("Sex parabeter has to contain a letter describing a sex");
}
}
/// <inheritdoc/>
public void ValidateParameters(FileCabinetRecord record)
{
if (!record.DateOfBirth.ValueInRange(this.fromDate, this.toDate))
{
throw new ArgumentException($"Date of birth can't be earlier {this.fromDate:yyyy-mm-dd} or later {this.toDate:yyyy-mm-dd}");
}
}
/// <summary>
/// Reads all.
/// </summary>
/// <returns>list of records.</returns>
public IList <FileCabinetRecord> ReadAll()
{
IList <FileCabinetRecord> records = new List <FileCabinetRecord>();
string line;
while ((line = this.reader.ReadLine()) != null)
{
if (!string.IsNullOrWhiteSpace(line))
{
string[] row = line.Split(',');
if (row[0].ToUpper(CultureInfo.InvariantCulture) == "ID")
{
continue;
}
try
{
FileCabinetRecord record = this.ValidateParameters(row);
this.validator.ValidateParameters(record);
records.Add(record);
}
catch (ArgumentNullException ex)
{
this.modelWriter.LineWriter.Invoke(ex.Message);
}
catch (ArgumentException ex)
{
this.modelWriter.LineWriter.Invoke(ex.Message);
}
}
}
return(records);
}
/// <summary>
/// Inserts new record and measure execution time.
/// </summary>
/// <param name="record">Record to insert.</param>
/// <returns>Id of inserted record.</returns>
/// <exception cref="ArgumentNullException">Thrown when record is null.</exception>
/// <exception cref="ArgumentException">Thrown when records data is invalid or when record with given id is already exists.</exception>
public int Insert(FileCabinetRecord record)
{
var stopWatch = Stopwatch.StartNew();
var result = this.service.Insert(record);
Console.WriteLine($"Insert method execution duration is {stopWatch.ElapsedTicks} ticks.");
return(result);
}
/// <inheritdoc/>
public bool Insert(FileCabinetRecord record)
{
var watch = Stopwatch.StartNew();
var result = this.service.Insert(record);
this.ShowTime(Source.Resource.GetString("insertTime", CultureInfo.InvariantCulture), watch.ElapsedTicks);
return(result);
}
/// <summary>
/// Inserts new record and writes info to log file.
/// </summary>
/// <param name="record">Record to insert.</param>
/// <returns>Id of inserted record.</returns>
/// <exception cref="ArgumentNullException">Thrown when record is null.</exception>
/// <exception cref="ArgumentException">Thrown when records data is invalid or when record with given id is already exists.</exception>
public int Insert(FileCabinetRecord record)
{
this.writer.WriteLine($"{DateTime.Now} Calling Insert.");
var result = this.service.Insert(record);
this.writer.WriteLine($"{DateTime.Now} Insert inserted record #{result}.");
return(result);
}
/// <summary>
/// Edits the record.
/// </summary>
/// <param name="record">The record.</param>
public void EditRecord(FileCabinetRecord record)
{
if (record is null)
{
throw new ArgumentNullException(nameof(record), $"{nameof(record)} is null");
}
this.MethodLogger(this.service.EditRecord, record, "update");
}
/// <summary>
/// Gets a list of records to import.
/// </summary>
/// <returns>List of records to import.</returns>
public IList <FileCabinetRecord> ReadAll()
{
List <FileCabinetRecord> readRecords = new List <FileCabinetRecord>();
_ = this.reader.ReadLine();
while (!this.reader.EndOfStream)
{
var nextRecord = this.reader.ReadLine();
var recordFields = nextRecord.Split(", ");
int nextRecordId;
DateTime nextRecordDateOfBirth;
decimal nextRecordWallet;
char nextRecordMaritalStatus;
short nextRecordHeight;
if (!int.TryParse(recordFields[0], out nextRecordId))
{
continue;
}
if (!DateTime.TryParse(recordFields[3], out nextRecordDateOfBirth))
{
continue;
}
if (!decimal.TryParse(recordFields[4], out nextRecordWallet))
{
continue;
}
if (!char.TryParse(recordFields[5], out nextRecordMaritalStatus))
{
continue;
}
if (!short.TryParse(recordFields[6], out nextRecordHeight))
{
continue;
}
var record = new FileCabinetRecord
{
Id = nextRecordId,
FirstName = recordFields[1],
LastName = recordFields[2],
DateOfBirth = nextRecordDateOfBirth,
Wallet = nextRecordWallet,
MaritalStatus = nextRecordMaritalStatus,
Height = nextRecordHeight,
};
readRecords.Add(record);
}
return(readRecords);
}
/// <summary>
/// Creates the record.
/// </summary>
/// <param name="record">record.</param>
/// <returns>
/// Id of created record.
/// </returns>
public int CreateRecord(FileCabinetRecord record)
{
if (record is null)
{
throw new ArgumentNullException(nameof(record), $"{nameof(record)} is null");
}
return(this.MethodLogger(this.service.CreateRecord, record, "create"));
}
private static string GetValuesString(FileCabinetRecord record, IEnumerable <int> lengths, IEnumerable <PropertyInfo> propertyInfos)
{
StringBuilder result = new StringBuilder(lengths.Sum() + (propertyInfos.Count() * 2));
int[] lengthsArr = lengths.ToArray();
int counter = 0;
int diff;
foreach (var property in propertyInfos)
{
var value = property.GetValue(record);
string valueStr;
if (value is DateTime temp)
{
valueStr = string.Format(CultureInfo.InvariantCulture, "{0}/{1}/{2}", temp.Month, temp.Day, temp.Year);
}
else
{
valueStr = value.ToString();
}
if (valueStr.Length == lengthsArr[counter])
{
result.Append('|' + valueStr + '|');
}
else
{
if (value is string || value is char)
{
result.Append('|' + valueStr);
diff = lengthsArr[counter] - valueStr.Length;
for (int i = 0; i < diff; i++)
{
result.Append(' ');
}
result.Append('|');
}
else
{
result.Append('|');
diff = lengthsArr[counter] - valueStr.Length;
for (int i = 0; i < diff; i++)
{
result.Append(' ');
}
result.Append(valueStr + '|');
}
}
counter++;
}
result.Append("\n");
return(result.ToString());
}
/// <summary>
/// Read records from file.
/// </summary>
/// <returns>Array of records.</returns>
public IList <FileCabinetRecord> ReadAll()
{
var list = new List <FileCabinetRecord>();
this.fileReader.BaseStream.Seek(0, 0);
var names = this.fileReader.ReadLine()?.Split(',', '.');
if (names is null || names.Length < 6)
{
Console.WriteLine(Source.Resource.GetString("badCsvFile", CultureInfo.InvariantCulture));
return(null);
}
int firstNameIndex = Array.IndexOf(names, "First Name");
int lastNameIndex = Array.IndexOf(names, "Last Name");
int dateIndex = Array.IndexOf(names, "Date of Birth");
int idindex = Array.IndexOf(names, "Id");
int sexIndex = Array.IndexOf(names, "Sex");
int weightIndex = Array.IndexOf(names, "Weight");
int heightIndex = Array.IndexOf(names, "Height");
while (!this.fileReader.EndOfStream)
{
try
{
var fields = this.fileReader.ReadLine()?.Split(',');
for (int i = 0; i < fields.Length; i++)
{
fields[i] = fields[i].Trim(' ', '.');
}
var record = new FileCabinetRecord();
record.Id = int.Parse(fields[idindex], CultureInfo.InvariantCulture);
record.FirstName = fields[firstNameIndex];
record.LastName = fields[lastNameIndex];
record.DateOfBirth = DateTime.Parse(fields[dateIndex], CultureInfo.InvariantCulture);
record.Sex = char.Parse(fields[sexIndex]);
record.Weight = decimal.Parse(fields[weightIndex], CultureInfo.InvariantCulture);
record.Height = short.Parse(fields[heightIndex], CultureInfo.InvariantCulture);
list.Add(record);
}
catch (IndexOutOfRangeException)
{
Console.WriteLine(Source.Resource.GetString("badCsvFile", CultureInfo.InvariantCulture));
continue;
}
catch (FormatException ex)
{
Console.WriteLine(ex.Message);
continue;
}
}
return(list);
}
/// <summary>Writes the specified record to the file.</summary>
/// <param name="record">The record to write.</param>
public void Write(FileCabinetRecord record)
{
this.writer.WriteLine();
if (record != null)
{
this.writer.Write(record.Id + ", " + record.FirstName + ", " + record.LastName + ", " +
record.DateOfBirth.ToString("MM/dd/yyyy", CultureInfo.InvariantCulture) + ", " +
record.Code + ", " + record.Letter + ", " + record.Balance);
}
}
private static void AddInDictionaryId(string key, FileCabinetRecord record)
{
isParse = int.TryParse(key, out int keyId);
IsParse(isParse, keyId);
if (!IdrecordDictionary.ContainsKey(keyId))
{
IdrecordDictionary.Add(keyId, new List <FileCabinetRecord> {
record
});
}
}
/// <inheritdoc/>
public void ValidateParameters(FileCabinetRecord recordParameters)
{
if (recordParameters == null)
{
throw new ArgumentNullException(nameof(recordParameters));
}
if (recordParameters.Wallet < this.minimumAmountOfMoney)
{
throw new ArgumentException(nameof(recordParameters.Wallet), $"The wallet state cannot be less than {this.minimumAmountOfMoney}.");
}
}
/// <inheritdoc/>
public void ValidateParameters(FileCabinetRecord record)
{
if (string.IsNullOrWhiteSpace(record.FirstName))
{
throw new ArgumentException("Firstname is empty.");
}
if (!record.FirstName.LengthInRange(this.minLength, this.maxLength))
{
throw new ArgumentException("Firstname length not in range.");
}
}
