public override User AddUser(User user)
{
if (user.Payer == null)
{
if (Payers.Count > 1)
{
throw new Exception($"У клиента более одного плательщика {Payers.Implode()}");
}
user.Payer = Payers.Single();
}
if (!user.Payer.Users.Contains(user))
{
user.Payer.Users.Add(user);
}
if (!Users.Contains(user))
{
Users.Add(user);
}
if (user.FirstTable)
{
user.Accounting.Payment = 0;
}
return(user);
}
//Add New Supplier to Database
public Boolean AddNewPayers(Payers payer)
{
Boolean insert;
try
{
insert = false;
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlCommand cmd = new SqlCommand("sp_InsertNewPayer", conn))
{
cmd.CommandTimeout = 200;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@PayerName", SqlDbType.NVarChar).Value = payer.PayerName;
cmd.Parameters.Add("@Phone", SqlDbType.NVarChar).Value = payer.Phone;
cmd.Parameters.Add("@Address", SqlDbType.NVarChar).Value = payer.Address;
cmd.Parameters.Add("@Email", SqlDbType.NVarChar).Value = payer.Email;
cmd.ExecuteNonQuery();
insert = true;
}
}
}
catch (SqlException ex)
{
throw new Exception("SQL Error : " + ex.Message);
}
return(insert);
}
public virtual bool ShouldSendNotification()
{
return(!Settings.ServiceClient && Settings.InvisibleOnFirm == DrugstoreType.Standart &&
Payers.All(p => p.Id != 921) &&
Addresses.Count > 0 &&
Enabled);
}
public async Task <IActionResult> PutPayers([FromRoute] int id, [FromBody] Payers payers)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != payers.Id)
{
return(BadRequest());
}
_payersRepository.UpdatePayer(payers);
try
{
_payersRepository.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!PayersExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//Update Payer status
public Boolean DeleteSelectedPayer(Payers payer)
{
Boolean update;
try
{
update = false;
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlCommand cmd = new SqlCommand("sp_UpdatePayerStatusById", conn))
{
cmd.CommandTimeout = 200;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@PayerID", SqlDbType.NVarChar).Value = payer.PayerID;
cmd.ExecuteNonQuery();
update = true;
}
}
}
catch (SqlException ex)
{
throw new Exception("SQL Error : " + ex.Message);
}
return(update);
}
public static IPayer GetPayer(Payers payer)
{
switch (payer)
{
case Payers.PayPal:
return(new PayPalPayer());
default:
return(new PayPalPayer());
}
}
public void RemovePayer(Person person)
{
Payer payer = GetPayer(person);
if (payer != null)
{
Payers.Remove(payer);
RecountDebtorsData();
}
}
public async Task <IActionResult> PostPayers([FromBody] Payers payers)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_payersRepository.CreatePayer(payers);
await _payersRepository.Save();
return(CreatedAtAction("GetPayers", new { id = payers.Id }, payers));
}
public void AddPayer(Person person, double payment)
{
if (!IsPersonInPayers(person))
{
Payer payer = new Payer(person, payment);
Payers.Add(payer);
}
else
{
GetPayer(person).Payment = payment;
}
RecountDebtorsData();
}
public string Info()
{
var userId = GetUserId();
var groupId = Convert.ToInt32(Context.Parameters["GroupId"]);
var paymentId = Context.Parameters["Id"];
string uID = userId.ToString();
string gID = Convert.ToString(Context.Parameters["GroupId"]);
string date = DateTime.Today.ToString();
string description = Data.Description;
string currency = Data.Currency;
string text = EmailService.Text(Payers.ToList(), Debtors.ToList(), uID, gID, date, description, currency);
return(text);
}
public void FilterPayersNames(string filter)
{
IEnumerable <TransactionData> payers = AllPayers;
if (!string.IsNullOrWhiteSpace(filter))
{
payers = payers.Where(t => t.Name.Contains(filter));
}
FilteredNames = payers.Select(t => t.Name) //select only names
.Concat(Payers.Select(t => t.Name)) //merge Names of allready added payers with names of all payers
.GroupBy(t => t).Where(g => g.Count() == 1).Select(g => g.Key).ToList(); //select only unique entries
MoveCurrentUserToTop(FilteredNames);
}
public void EditRow(TransactionRowData row, string context)
{
if (context == "payers")
{
var item = Payers.Find(n => n == row);
item.Name = "";
item.IsUserboxVisible = false;
}
else if (context == "debtors")
{
var item = Debtors.Find(n => n == row);
item.Name = "";
item.IsUserboxVisible = false;
}
}
public virtual void AddBillingComment(string billingMessage)
{
if (String.IsNullOrEmpty(billingMessage))
{
return;
}
new AuditRecord("Сообщение в биллинг: " + billingMessage, this).Save();
var user = Users.FirstOrDefault();
if (user == null)
{
return;
}
billingMessage = String.Format("О регистрации клиента: {0} ( {1} ), пользователь: {2} ( {3} ): {4}", Id, Name, user.Id, user.Name, billingMessage);
Payers.Single().AddComment(billingMessage);
}
public virtual void Delete(ISession session)
{
foreach (var user in Users.ToArray())
{
user.Delete();
}
foreach (var address in Addresses.ToArray())
{
address.Delete();
}
var payers = Payers.ToArray();
Payers.Clear();
foreach (var payer in payers)
{
//какая то фигня с загрузкой объектов
payer.Clients.Remove(payer.Clients.First(c => c.Id == Id));
if (payer.CanDelete(session))
{
session.Delete(payer);
}
else
{
payer.UpdatePaymentSum();
}
}
var rule = Settings.SmartOrderRules;
if (rule != null)
{
var overHaveSameSettins = ActiveRecordLinqBase <DrugstoreSettings> .Queryable.Any(s => s.Id != Id && s.SmartOrderRules == rule);
if (!overHaveSameSettins)
{
Settings.SmartOrderRules = null;
session.Delete(rule);
}
}
AuditRecord.DeleteAuditRecords(this);
session.Delete(this);
}
protected virtual void CommonChangePayer(Action changer, Payer payer)
{
var oldPayers = Payers.ToArray();
Payers.Clear();
Payers.Add(payer);
foreach (var user in Users)
{
user.Payer.Users.Remove(user);
user.Payer = payer;
user.Payer.Users.Add(user);
}
changer();
payer.UpdatePaymentSum();
foreach (var oldPayer in oldPayers)
{
oldPayer.UpdatePaymentSum();
}
}
public void AddSelectedUser(string name, TransactionRowData row, string context)
{
if (context == "payers")
{
var user = AllPayers.FirstOrDefault(n => n.Name == name);
if (user != null)
{
var item = Payers.First(n => n.RowId == row.RowId);
item.Name = user.Name;
item.UserId = user.UserId;
item.ImageUrl = user.ImageUrl;
item.Id = user.Id;
item.IsUserboxVisible = true;
}
if (AllPayers.Count > Payers.Count)
{
AddRow(Payers);
}
}
else if (context == "debtors")
{
var user = AllDebtors.FirstOrDefault(n => n.Name == name);
if (user != null)
{
var item = Debtors.First(n => n.RowId == row.RowId);
item.Name = user.Name;
item.UserId = user.UserId;
item.ImageUrl = user.ImageUrl;
item.Id = user.Id;
item.IsUserboxVisible = true;
}
if (AllDebtors.Count > Debtors.Count)
{
AddRow(Debtors);
}
}
}
//Populate GridView
public List <Payers> GetPayersDetails()
{
List <Payers> Payerslist = null;
try
{
Payerslist = new List <Payers>();
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlCommand cmd = new SqlCommand("sp_getAllPayers", conn))
{
cmd.CommandTimeout = 200;
cmd.CommandType = CommandType.StoredProcedure;
dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
while (dr.Read())
{
Payers payer = new Payers();
payer.Address = (string)dr["Address"];
payer.Email = (string)dr["Email"];
payer.Phone = (string)dr["Phone"];
payer.PayerID = (string)dr["PayerID"];
payer.PayerName = (string)dr["PayerName"];
Payerslist.Add(payer);
}
dr.Close();
}
}
}
catch (SqlException ex)
{
throw new Exception("SQL Error : " + ex.Message);
}
return(Payerslist);
}
public virtual void ChangePayer(ISession session, Payer payer)
{
var oldPayers = Payers.ToArray();
CommonChangePayer(() => {
foreach (var address in Addresses)
{
address.Payer.Addresses.Remove(address);
address.Payer = payer;
address.Payer.Addresses.Add(address);
}
var legalEntities = oldPayers.SelectMany(p => p.Orgs).ToList();
if (legalEntities.Count > 1)
{
throw new Exception(string.Format("Количество ЮрЛиц у клиента {0} более одного, не могу поменять плательщика у клиента", Id));
}
var legalEntity = legalEntities.First();
legalEntity.Payer = payer;
session.SaveOrUpdate(legalEntity);
}, payer);
}
public virtual IEnumerable <IAuditRecord> GetAuditRecords(IEnumerable <AuditableProperty> properties)
{
if (properties != null && properties.Any(p => p.Property.Name.Equals("Status")))
{
return(Payers.Select(payer => new PayerAuditRecord(payer, "$$$", EditComment)
{
ShowOnlyPayer = true,
ObjectType = LogObjectType.Client,
ObjectId = Id,
Name = Name
})
.Cast <IAuditRecord>()
.Concat(new[] { new AuditRecord(this)
{
MessageType = LogMessageType.System, Type = LogObjectType.Client, Name = Name
} }));
}
return(new List <IAuditRecord> {
new AuditRecord(this)
{
MessageType = LogMessageType.System, Type = LogObjectType.Client, Name = Name
}
});
}
protected void DeleteFormerMembers(Payers payer)
{
List<int> dbMembers = (from m in db.payNewPatients
where m.payPayerId == (int)payer
&& m.Active == true
select m.payNewPatientId).ToList();
var membersToDelete = dbMembers.Except(this.currentMembers).ToList();
foreach (var patientId in membersToDelete)
{
//first update payFileImportData
dat.payNewPatients pat = db.payNewPatients.Where(i => i.payNewPatientId == patientId).First();
UpdateFileImportData(patientId, fileImport.payFileImport, false, true, pat.NG_provider_id);
pat.Active = false;
db.SaveChanges();
_deletedMemberCount += 1;
}
}
public void DeletePayer(TransactionData payer)
{
Payers.Remove(payer);
EnsureInsertRowPresent(Payers);
Recalculate();
}
public virtual IList <LegalEntity> GetLegalEntity()
{
return(Payers.SelectMany(p => p.Orgs).ToList());
}
public void UpdatePayer(Payers Payer)
{
dataRepository.Entry(Payer);
}
public void UpdatePayer(Payers Payer)
{
context.Entry(Payer).State = EntityState.Modified;
}
//update file import table
protected int UpdateFileImportsTable(Payers payer, string fileName)
{
if (fileImport == null)
{
fileImport = new payFileImports();
}
fileImport.DeletedMembers = _deletedMemberCount;
fileImport.NewMembers = _newMemberCount;
fileImport.MemberCount = _activeMemberCount;
fileImport.Filename = fileName;
fileImport.ImportTimeStamp = DateTime.Now;
fileImport.Month = DateTime.Now.Month;
fileImport.payPayerId = (int)payer;
fileImport.Year = DateTime.Now.Year;
if (fileImport.payFileImport == 0)
{
db.AddTopayFileImports(fileImport);
}
db.SaveChanges();
return fileImport.payFileImport;
}
public void CreatePayer(Payers Payer)
{
dataRepository.Add(Payer);
}
/// <summary>
/// Recalculates the remaining amount.
/// </summary>
public void Recalculate()
{
AmountDifference = (Payers.Where(p => p.Amount != null).Sum(p => p.Amount) ?? 0) - (Debtors.Where(p => p.Amount != null).Sum(p => p.Amount) ?? 0);
}
public virtual bool ShouldNotify()
{
return(Payers.All(p => p.Id != 921));
}
public async Task DeletePayer(Payers Payer)
{
context.Payers.Remove(Payer);
}
public void Setup()
{
payers = new Payers();
BaseTestClass.SetConfiguration();
}
public virtual void JoinPayer(Payer payer)
{
Payers.Add(payer);
}
public virtual IEnumerable <LegalEntity> Orgs()
{
return(Payers.SelectMany(p => p.Orgs));
}
public void Setup()
{
payers = new Payers();
restClient = new Mock<IRequestExecute>();
param = new Hashtable();
}
