public IEnumerable <string> GetLineSelectedNumbers(int lineId)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
List <string> list = new List <string>();
SelectedNumbers entity = db.SelectedNumbers.Where(s => s.Line.LineId == lineId).FirstOrDefault();
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName.EndsWith("Number"))
{
if (db.Entry(entity).Property(propName).CurrentValue != null)
{
list.Add(db.Entry(entity).Property(propName).CurrentValue.ToString());
}
}
}
return(list);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <LineDto> CreateLine(LineDto lineDto, SelectedNumberDto selectedNumberDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (lineDto == null)
{
return(null);
}
else
{
lineDto.SelectedNumbers = selectedNumberDto;
db.Lines.Add(lineDto.ToModel());
await db.SaveChangesAsync();
return(lineDto);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <PackageDto> UpdatePackage(int id, PackageDto packageDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (id != packageDto.PackageId)
{
return(null);
}
else
{
Package p = db.Packages.FirstOrDefault(c => c.PackageId == id);
if (p == null)
{
return(null);
}
else
{
p = packageDto.ToModel();
db.Entry(p).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
return(p.ToDto());
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public bool CheckIfLineNumberAlreadyExist(string number)
{
using (var db = new CellularCompanyContext())
{
return(db.Lines.All(l => l.Number == number));
}
}
public async Task <PackageDto> DeletePackage(int id)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
Package package = await db.Packages.FindAsync(id);
if (package == null)
{
return(null);
}
else
{
db.Packages.Remove(package);
await db.SaveChangesAsync();
return(package.ToDto());
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <PackageDto> CreatePackage(PackageDto packageDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (packageDto == null)
{
return(null);
}
else
{
db.Packages.Add(packageDto.ToModel());
await db.SaveChangesAsync();
return(packageDto);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <bool> DeleteLine(int lineId)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
var line = db.Lines.FirstOrDefault(l => l.LineId == lineId);
if (line != null)
{
var selectedNumbers = db.SelectedNumbers.FirstOrDefault(l => l.Id == line.LineId);
db.SelectedNumbers.Remove(selectedNumbers);
db.Lines.Remove(line);
await db.SaveChangesAsync();
return(true);
}
return(false);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(false);
}
}
}
public async Task <PackageDto> CreatePackage(PackageDto package, PackageIncludesDto packageIncludes)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (package != null)
{
PackageEntity entity = new PackageEntity()
{
PackageName = package.PackageName,
PackageTotalPrice = package.PackageTotalPrice,
};
db.PackageIncludes.Add(packageIncludes.ToModel());
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <SMSDto> UpdateSMS(int id, SMSDto smsDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
if (id != smsDto.SMSId)
{
return(null);
}
else
{
var sms = db.SMSs.FirstOrDefault(s => s.SMSId == id);
if (sms == null)
{
return(null);
}
else
{
SMS sMS = smsDto.ToModel();
db.Entry(sMS).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
return(sms.ToDto());
}
}
}
}
public async Task <LineDto> UpdateLine(int id, LineDto lineDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (lineDto != null && id != 0 && CheckIfLineNumberAlreadyExist(lineDto.Number))
{
lineDto.LineId = id;
Line entity = lineDto.ToModel();
db.Lines.Attach(entity);
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName != nameof(entity.LineId))
{
db.Entry(entity).Property(propName).IsModified = true;
}
}
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <PaymentDto> UpdatePayment(PaymentDto payment)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (payment != null)
{
PaymentEntity entity = payment.ToModel();
entity.PaymentId = payment.PaymentId;
db.Payment.Attach(entity);
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName != "PaymentId")
{
db.Entry(entity).Property(propName).IsModified = true;
}
}
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <LineDto> UpdateLine(LineDto line, string clientId)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (line != null)
{
if (line.ClientId == clientId)
{
LineEntity entity = line.ToModel();
entity.LineId = line.LineId;
db.Lines.Attach(entity);
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName != "LineId")
{
db.Entry(entity).Property(propName).IsModified = true;
}
}
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <PackageDto> UpdatePackage(PackageDto package, int lineId, string clientId)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (package != null)
{
if (CheckIfPackageBelongsToClient(package, lineId, clientId))
{
PackageEntity entity = package.ToModel();
entity.PackageId = package.PackageId;
db.Packages.Attach(entity);
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName != "PackageId")
{
db.Entry(entity).Property(propName).IsModified = true;
}
}
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <CallsDto> UpdateCall(CallsDto call)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (call != null)
{
CallsEntity entity = call.ToModel();
entity.CallId = call.CallId;
db.Calls.Attach(entity);
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName != "CallId")
{
db.Entry(entity).Property(propName).IsModified = true;
}
}
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
private bool CheckIfPackageBelongsToClient(PackageDto package, int lineId, string clientId)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
LineRepository lineRepository = new LineRepository();
LineDto line = lineRepository.GetLine(lineId);
if (line != null)
{
if (line.PackageId == package.PackageId)
{
if (line.ClientId == clientId)
{
return(true);
}
return(false);
}
return(false);
}
return(false);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(false);
}
}
public async Task <CustomerTypeDto> DeleteCustomerType(int id)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
CustomerType customerType = await db.CustomerTypes.FindAsync(id);
if (customerType == null)
{
return(null);
}
else
{
db.CustomerTypes.Remove(customerType);
await db.SaveChangesAsync();
return(customerType.ToDto());
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <ClientDto> UpdateClient(ClientDto client, string clientId)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (client != null && clientId != null)
{
client.ClientId = clientId;
ClientEntity entity = client.ToModel();
db.Clients.Attach(entity);
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName != nameof(entity.ClientId))
{
db.Entry(entity).Property(propName).IsModified = true;
}
}
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <CustomerTypeDto> CreateCustomerType(CustomerTypeDto customerTypeDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (customerTypeDto == null)
{
return(null);
}
else
{
db.CustomerTypes.Add(customerTypeDto.ToModel());
await db.SaveChangesAsync();
return(customerTypeDto);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <SelectedNumbersDto> UpdateSelectedNumber(SelectedNumbersDto number)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (number != null)
{
SelectedNumbersEntity entity = number.ToModel();
entity.Id = number.Id;
db.SelectedNumbers.Attach(entity);
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName != "Id")
{
db.Entry(entity).Property(propName).IsModified = true;
}
}
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public IEnumerable <SMSDto> GetSMSs(string clientId)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
ClientEntity client = db.Clients.FirstOrDefault(c => c.ClientId == clientId);
var lines = db.Lines.Where(c => c.ClientId == clientId).ToList();
List <SMSDto> smss = new List <SMSDto>();
List <SMSEntity> smsEntities = new List <SMSEntity>();
foreach (var item in lines)
{
var smssList = db.SMS.Where(s => s.LineId == item.LineId).ToList();
smsEntities.AddRange(smssList);
}
foreach (var item in smsEntities)
{
smss.Add(item.ToDto());
}
return(smss);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <SMSDto> UpdateSMS(SMSDto sms)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (sms != null)
{
SMSEntity entity = sms.ToModel();
entity.SMSId = sms.SMSId;
db.SMS.Attach(entity);
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName != "SMSId")
{
db.Entry(entity).Property(propName).IsModified = true;
}
}
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <SelectedNumberDto> UpdateSelectedNumber(int id, SelectedNumberDto selectedNumberDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
if (id != selectedNumberDto.SelectedNumberId)
{
return(null);
}
else
{
var sn = db.SelectedNumbers.FirstOrDefault(s => s.SelectedNumberId == id);
if (sn == null)
{
return(null);
}
else
{
SelectedNumbers selectedNumber = selectedNumberDto.ToModel();
db.Entry(selectedNumber).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
return(sn.ToDto());
}
}
}
}
public async Task <PaymentDto> UpdatePayment(int id, PaymentDto paymentDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
if (id != paymentDto.CustomerId)
{
return(null);
}
else
{
var py = db.Payments.FirstOrDefault(p => p.PaymentId == id);
if (py == null)
{
return(null);
}
else
{
Payment payment = paymentDto.ToModel();
db.Entry(payment).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
return(py.ToDto());
}
}
}
}
public async Task <CustomerTypeDto> UpdateCustomerType(int id, CustomerTypeDto customerTypeDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (id != customerTypeDto.CustomerTypeId)
{
return(null);
}
else
{
CustomerType ct = db.CustomerTypes.FirstOrDefault(c => c.CustomerTypeId == id);
if (ct == null)
{
return(null);
}
else
{
ct = customerTypeDto.ToModel();
db.Entry(ct).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
return(ct.ToDto());
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <PaymentDto> GetPayment(int id)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
Payment payment = await db.Payments.FindAsync(id);
return(payment.ToDto());
}
}
public async Task <IEnumerable <PaymentDto> > GetPayments()
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
IEnumerable <Payment> payments = await db.Payments.ToListAsync();
return(payments.Select(py => py.ToDto()).ToList());
}
}
public async Task <SelectedNumberDto> GetSelectedNumber(int id)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
SelectedNumbers selectedNumber = await db.SelectedNumbers.FindAsync(id);
return(selectedNumber.ToDto());
}
}
public async Task <SMSDto> GetSMS(int id)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
SMS sms = await db.SMSs.FindAsync(id);
return(sms.ToDto());
}
}
public async Task <IEnumerable <SMSDto> > GetSMSes()
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
IEnumerable <SMS> smses = await db.SMSs.ToListAsync();
return(smses.Select(s => s.ToDto()).ToList());
}
}
public async Task <IEnumerable <SelectedNumberDto> > GetSelectedNumbers()
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
IEnumerable <SelectedNumbers> selectedNumbers = await db.SelectedNumbers.ToListAsync();
return(selectedNumbers.Select(cstmr => cstmr.ToDto()).ToList());
}
}
