HRM_RabbitMQ_Consumer/JSONParser/QDocWrapper/QDocWrapper.cs

using JSONParser.Structure;
using Simple.OData.Client;

namespace JSONParser.QDocWrapper
{
    public class QDocWrapper
    {
        ODataClient _client;
        Logger.Logger _logger;
        public QDocWrapper(ODataClient client, Logger.Logger logger)
        {
            _client = client;
            _logger = logger;
        }

        public async Task<long> CreateEmployee(Employee employee)
        {
            if (employee == null) return 0;

            var emp = await _client
                .For("IEmployee")
                .Expand("Department")
                .Expand("Person")
                .Expand("JobTitle")
                .Expand("Login")
                .Filter($"ExternalId eq '{employee.Sid}' and Status eq 'Active'")
                //.Filter($"ExternalId eq '{employee.Sid}'")
                .FindEntryAsync();

            if ((employee.Person == null || employee.Department == null) || employee.Status == false && emp == null)
            {
                _logger.Warn($"{employee.Type} - {employee.Sid} - Skip");
                return 0;
            }

            long result = 0;

            if (employee.Department != null)
            {
                var id = await employee.Department.GetIdBySid(_client);
                employee.Department.DirectumId = id;
            }
            else
            {
                dynamic empDept = emp["Department"];
                employee.Department = new Department
                {
                    Sid = (string)empDept["ExternalId"],
                    DirectumId = (long)empDept["Id"],
                    Name = (string)empDept["Name"],
                    ShortName = (string)empDept["ShortName"]
                };
                employee.JobTitle.Department = employee.Department;
            }

            if (employee.Person != null)
            {
                var id = await employee.Person.GetIdBySid(_client);
                if (id == 0)
                {
                    id = await employee.Person.Create(_client);
                }
                employee.Person.DirectumId = id;
            }
            else
            {
                dynamic empPerson = emp["Person"];
                employee.Person = new Person { DirectumId = (long)empPerson["Id"] };
            }

            if (employee.JobTitle != null)
            {
                var id = await employee.JobTitle.GetIdBySid(_client);
                employee.JobTitle.DirectumId = id;
            }
            else
            {
                dynamic empJobTitle = emp["JobTitle"];
                employee.JobTitle = new JobTitle { DirectumId = (long)empJobTitle["Id"] };
            }

            if (employee.Login != null)
            {
                dynamic currLogin = emp["Login"];
                string loginName = currLogin["LoginName"];
                var id = await employee.Login.GetIdBySid(_client);
                if (id != 0 && !loginName.Equals(employee.Login.LoginName))
                {
                    long currId = currLogin["Id"];
                    employee.Login.CloseLogin(_client, currId);
                    employee.Login.OpenLogin(_client, id);
                }
                if (id == 0)
                {
                    id = await employee.Login.Create(_client);
                }
                employee.Login.DirectumId = id;
            }
            else if (emp != null)
            {
                dynamic empLogin = emp["Login"];
                if (empLogin != null)
                {
                    employee.Login = new Login { DirectumId = (long)empLogin["Id"] };
                }
            }

            if (employee.Person.DirectumId == 0 || employee.Department.DirectumId == 0 || employee.JobTitle.DirectumId == 0)
            {
                _logger.Info($"{employee.Type} - {employee.Sid} - Not Valid");
                return result;
            }

            var empByLogin = await employee.FindByLogin(_client);
            if (emp != null && employee.IsEqual(emp))
            {
                result = (long)emp["Id"];
                employee.DirectumId = result;
                _logger.Info($"{employee.Type} - {employee.Sid} - Unchanged");
            }
            else if (emp != null && empByLogin == 0)
            {
                result = (long)emp["Id"];
                await employee.Update(_client, result);
                employee.DirectumId = result;
                _logger.Info($"{employee.Type} - {employee.Sid} - Updated");
            }
            else if (emp != null && empByLogin > 0)
            {
                result = (long)emp["Id"];
                if (result != empByLogin)
                {
                    await employee.CloseRecord(_client, empByLogin);
                    _logger.Info($"{employee.Type} - {employee.Sid} - Closed");
                }
                await employee.Update(_client, result);
                employee.DirectumId = result;
                _logger.Info($"{employee.Type} - {employee.Sid} - Updated");
            }
            else if (emp == null && empByLogin > 0)
            {
                await employee.CloseRecord(_client, empByLogin);
                _logger.Info($"{employee.Type} - {employee.Sid} - Closed");
                if (employee.Person != null && employee.Department != null)
                {
                    result = await employee.Create(_client);
                    _logger.Info($"{employee.Type} - {employee.Sid} - Created");
                }
            }
            else
            {
                if (employee.Person != null && employee.Department != null)
                {
                    result = await employee.Create(_client);
                    _logger.Info($"{employee.Type} - {employee.Sid} - Created");
                }
            }
            return result;
        }

        public async Task<long> CreateDepartment(Department department)
        {
            if (department == null || department.Status == "Closed" || string.IsNullOrEmpty(department.Name)) return 0;
            if (department.HeadOffice != null && department.HeadOffice.DirectumId == null)
            {
                var id = await department.HeadOffice.GetIdBySid(_client);
                if (id > 0)
                {
                    department.HeadOffice.DirectumId = id;
                }
            }
            if (department.BusinessUnit != null && department.BusinessUnit.DirectumId == null)
            {
                var id = await department.BusinessUnit.GetIdBySid(_client);
                if (id > 0)
                {
                    department.BusinessUnit.DirectumId = id;
                }
            }
            var dept = await _client
                .For("IDepartment")
                .Expand("BusinessUnit")
                .Expand("HeadOffice")
                .Filter($"ExternalId eq '{department.Sid}'")
                .FindEntryAsync();
            long result = 0;

            if (department.BusinessUnit.DirectumId == 0)
            {
                _logger.Info($"{department.Type} - {department.Sid} - Not Valid");
                return result;
            }

            if (dept != null && department.IsEqual(dept))
            {
                result = (long)dept["Id"];
                department.DirectumId = result;
                _logger.Info($"{department.Type} - {department.Sid} - Unchanged");
            }
            else if (dept != null)
            {
                result = (long)dept["Id"];
                await department.Update(_client, result);
                department.DirectumId = result;
                _logger.Info($"{department.Type} - {department.Sid} - Updated");
            }
            else
            {
                result = await department.Create(_client);
                _logger.Info($"{department.Type} - {department.Sid} - Created");
            }
            return result;
        }

        public async Task<long> CreateJobTitle(JobTitle jobTitle)
        {
            if (jobTitle == null) return 0;
            long result = 0;
            var job = await _client
                .For("IJobTitles")
                .Expand("Department")
                .Filter($"Name eq '{jobTitle.Name}' and Department/ExternalId eq '{jobTitle.Department.Sid}'")
                .FindEntryAsync();

            if (jobTitle.Department != null)
            {
                await jobTitle.Department.GetIdBySid(_client);
            }

            if (job != null && jobTitle.IsEqual(job))
            {
                result = (long)job["Id"];
                jobTitle.DirectumId = result;
                dynamic dept = job["Department"];
                jobTitle.Department.DirectumId = (long)dept["Id"];
                _logger.Info($"{jobTitle.Type} - {jobTitle.Sid} - Unchanged");
            }
            else if (job != null)
            {
                result = (long)job["Id"];
                await jobTitle.Update(_client, result);
                jobTitle.DirectumId = result;
                dynamic dept = job["Department"];
                jobTitle.Department.DirectumId = (long)dept["Id"];
                _logger.Info($"{jobTitle.Type} - {jobTitle.Sid} - Updated");
            }
            else
            {
                if (jobTitle.Department != null)
                {
                    result = await jobTitle.Create(_client);
                    _logger.Info($"{jobTitle.Type} - {jobTitle.Sid} - Created");
                }
            }
            return result;
        }

        public async Task<long> CreatePerson(Person person)
        {
            if (person == null) return 0;
            var per = await _client
                .For("IPersons")
                .Filter($"ExternalId eq '{person.Sid}'")
                .FindEntryAsync();
            long result;
            if (per != null && person.IsEqual(per))
            {
                result = (long)per["Id"];
                person.DirectumId = result;
                _logger.Info($"{person.Type} - {person.Sid} - Unchanged");
            }
            else if (per != null)
            {
                result = (long)per["Id"];
                await person.Update(_client, result);
                person.DirectumId = result;
                _logger.Info($"{person.Type} - {person.Sid} - Updated");
            }
            else
            {
                result = await person.Create(_client);
                _logger.Info($"{person.Type} - {person.Sid} - Created");
            }
            return result;
        }

        public async Task<long> CreateBusinessUnit(BusinessUnit businessUnit)
        {
            if (businessUnit == null) return 0;
            if (businessUnit.HeadCompany != null && businessUnit.HeadCompany.DirectumId == null)
            {
                var id = await businessUnit.HeadCompany.GetIdBySid(_client);
                if (id > 0)
                {
                    businessUnit.HeadCompany.DirectumId = id;
                }
            }
            long result = 0;
            var bu = await _client
                .For("IBusinessUnits")
                .Expand("HeadCompany")
                .Filter($"ExternalId eq '{businessUnit.Sid}'")
                .FindEntryAsync();

            if (bu != null && businessUnit.IsEqual(bu))
            {
                result = (long)bu["Id"];
                businessUnit.DirectumId = result;
                _logger.Info($"{businessUnit.Type} - {businessUnit.Sid} - Unchanged");
            }
            else if (bu != null)
            {
                result = (long)bu["Id"];
                await businessUnit.Update(_client, result);
                businessUnit.DirectumId = result;
                _logger.Info($"{businessUnit.Type} - {businessUnit.Sid} - Updated");
            }
            else
            {
                result = await businessUnit.Create(_client);
                _logger.Info($"{businessUnit.Type} - {businessUnit.Sid} - Created");
            }
            return result;
        }

        public async Task<long> CreateLogin(Login login)
        {
            if (login == null) return 0;
            long result = 0;
            var log = await _client
                .For("ILogins")
                .Filter($"LoginName eq '{login.LoginName}'")
                .FindEntryAsync();
            if (log != null && login.IsEqual(log))
            {
                result = (long)log["Id"];
                login.DirectumId = result;
                _logger.Info($"{login.Type} - {login.Sid} - Unchanged");
            }
            else if (log != null)
            {
                result = (long)log["Id"];
                await login.Update(_client, result);
                login.DirectumId = result;
                _logger.Info($"{login.Type} - {login.Sid} - Updated");
            }
            else
            {
                result = await login.Create(_client);
                _logger.Info($"{login.Type} - {login.Sid} - Created");
            }
            return result;
        }
    }
}