UnivatePropertiesAPI/UnivateProperties_API/Repository/Properties/PropertyRepository.cs

#define ReturnImages
//#undef ReturnImages  //Comment out to return images

using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnivateProperties_API.Containers.Property;
using UnivateProperties_API.Containers.Timeshare;
using UnivateProperties_API.Context;
using UnivateProperties_API.Model.Logging;
using UnivateProperties_API.Model.Properties;

namespace UnivateProperties_API.Repository.Properties
{
    public class PropertyRepository : IPropertyRepository
    {
        private readonly DataContext dBContext;

        public PropertyRepository(DataContext _dBContext)
        {
            dBContext = _dBContext;
        }

        public List<Property> Get(Func<Property, bool> where)
        {
            return dBContext.Properties
                .Include("PropertyType")
                .Include("Province")
                .Include("City")
                .Include("Suburb")
                .Where(where).ToList();
        }

        public List<Property> GetAll()
        {
            var properties = dBContext.Properties.ToList();
            return properties;
        }

        public Property GetDetailed(Func<Property, bool> first)
        {
            throw new NotImplementedException();            
        }

        public PropertyContainer GetDetailed(int id, bool detailed)
        {
            var property = dBContext.Properties.Include("Status").Where(p => p.Id == id).FirstOrDefault();            
            if (property != null)
            {
                return GetDetail(property, detailed);
            }
            return null;
        }

        public List<Property> GetDetailedAll()
        {
            var properties = dBContext.Properties.ToList();
            return properties;
        }

        private PropertyContainer GetDetail(Property property, bool detailed)
        {            
            int propID = property.Id;
            var propertyType = dBContext.PropertyTypes.Find(property.PropertyTypeId);
            property.Province = dBContext.Provinces.Find(property.ProvinceId);
            property.City = dBContext.Cities.Find(property.CityId);
            property.Suburb = dBContext.Suburbs.Find(property.SuburbId);
            property.DisplayData = new List<PropertyDetailGroup>();            

            if (detailed)
            {
                var groups = (from g in dBContext.UserDefinedGroups
                              where g.UsageType == propertyType.UsageType
                              || g.UsageType == PropertyUsageType.Both
                              orderby g.Rank
                              select g).ToList();

                foreach (UserDefinedGroup uGroup in groups)
                {
                    var groupFields = (from f in dBContext.PropertyUserFields
                                       join uf in dBContext.UserDefinedFields on f.UserDefinedFieldId equals uf.Id
                                       join g in dBContext.UserDefinedGroups on uf.GroupId equals g.Id
                                       where f.PropertyId == propID
                                       && g.Id == uGroup.Id
                                       orderby g.Rank, uf.Rank
                                       select new { uf.FieldName, f.Value, f.Description }).ToList();

                    if (groupFields.Count > 0)
                    {
                        PropertyDetailGroup detailGroup = new PropertyDetailGroup()
                        {
                            GroupName = uGroup.Description,
                            Values = new List<PropertyDetail>()
                        };

                        if (uGroup.Description == "Property Overview")
                        {
                            detailGroup.Values.Add(new PropertyDetail()
                            {
                                Name = "Property Type",
                                Value = property.PropertyType.Description
                            });
                        }

                        foreach (var val in groupFields)
                        {
                            var item = new PropertyDetail()
                            {
                                Name = val.FieldName,
                                Description = val.Description
                            };

                            detailGroup.Values.Add(item);

                            if (!string.IsNullOrEmpty(val.Value) && (val.FieldName == "Erf Size" || val.FieldName == "Floor Size") && val.Value.EndsWith("2"))
                            {
                                item.Value = val.Value.Substring(0, val.Value.Length - 1) + "<sup>" + val.Value.Last() + "</sup>";
                            }
                            else
                                item.Value = val.Value;
                        }

                        property.DisplayData.Add(detailGroup);
                    }
                }
            }
            else
            {
                if (!string.IsNullOrEmpty(property.Video))
                    property.Video = string.Format("https://www.youtube.com/watch?v={0}", property.Video);
            }

            var propertyDetails = new PropertyContainer();

            foreach (string prop in property.GetAllProperties())
            {
                if (prop != "Item" && prop != "Display")
                    propertyDetails[prop] = property[prop];
            }            

            propertyDetails.PropertyUsageType = propertyType.UsageType == PropertyUsageType.Commercial ? "Commercial" : "Residential";

            if (property.OwnerId > 0)
                propertyDetails.UserId = (dBContext.Individuals.Where(p => p.Id == property.OwnerId).FirstOrDefault().UserId).Value;
            if (property.AgentId > 0)
                propertyDetails.UserId = (dBContext.Agents.Where(p => p.Id == property.AgentId).FirstOrDefault().UserId).Value;

            propertyDetails.NewImages = new List<NewImage>();

            return propertyDetails;
        }

        public void Insert(Property item)
        {
            throw new NotImplementedException();
        }

        public void Insert(IEnumerable<Property> items)
        {
            foreach (var item in items)
            {
                dBContext.Properties.Add(item);
            }
            Save();
        }

        public void Remove(Property item)
        {
            item.IsDeleted = true;
            Save();
        }

        public void Remove(IEnumerable<Property> items)
        {
            foreach (var item in items)
            {
                item.IsDeleted = true;
            }
            Save();
        }

        public void RemoveAtId(int item)
        {
            var property = Get(x => x.Id == item).FirstOrDefault();
            if (property != null)
            {
                dBContext.Properties.Remove(property);
                Save();
            }
        }

        public void Save()
        {
            dBContext.SaveChanges();
        }

        public void Update(Property item)
        {
            if (item.Video.StartsWith("http"))
                item.Video = item.Video.Replace("https://www.youtube.com/watch?v=", "");

            dBContext.Entry(item).State = EntityState.Modified;
            Save();
        }

        public void Update(PropertyContainer item)
        {
            if (item.Video.StartsWith("http"))
                item.Video = item.Video.Replace("https://www.youtube.com/watch?v=", "");

            var property = new Property();
            foreach (string prop in property.GetAllProperties())
            {
                if (prop != "Item" && prop != "Display")
                    property[prop] = item[prop];
            }

            property.PropertyUserFields = null;
            property.PropertyImages = null;

            dBContext.Entry(property).State = EntityState.Modified;            

            #region Insert New UDFs

            foreach (var propGroup in item.PropertyOverviewFields)
            {
                foreach (var field in propGroup.Fields)
                {
                    if (field.ItemId == 0)
                    {                        
                        var propertyField = new PropertyUserField()
                        {                            
                            PropertyId = property.Id,
                            UserDefinedFieldId = field.Id,
                            Value = field.Value
                        };
                        dBContext.Add(propertyField);                        
                    }
                    else
                    {
                        var propertyField = dBContext.PropertyUserFields.Where(p => p.Id == field.ItemId).FirstOrDefault();
                        if (propertyField != null)
                        {
                            if (string.IsNullOrEmpty(field.Value))
                                propertyField.IsDeleted = true;
                            else
                                propertyField.Value = field.Value;

                            dBContext.Entry(propertyField).State = EntityState.Modified;                            
                        }
                    }
                }
            }

            foreach (var propGroup in item.PropertyFields)
            {
                foreach (var field in propGroup.Fields)
                {
                    if (field.ItemId == 0)
                    {                        
                        var propertyField = new PropertyUserField()
                        {                            
                            PropertyId = property.Id,
                            UserDefinedFieldId = field.Id,
                            Value = field.Value
                        };
                        dBContext.Add(propertyField);                        
                    }
                    else
                    {
                        var propertyField = dBContext.PropertyUserFields.Where(p => p.Id == field.ItemId).FirstOrDefault();
                        if (propertyField != null)
                        {
                            if (string.IsNullOrEmpty(field.Value))
                                propertyField.IsDeleted = true;
                            else
                                propertyField.Value = field.Value;

                            dBContext.Entry(propertyField).State = EntityState.Modified;                            
                        }
                    }
                }
            }
            #endregion

            #region Update Images            

            if (item.PropertyImages != null)
            {
                foreach (var image in item.PropertyImages)
                {
                    var propImage = dBContext.PropertyImages.Where(pi => pi.Id == image.Id).FirstOrDefault();
                    if (propImage != null)
                    {
                        propImage.IsDefault = image.IsDefault;
                        propImage.IsDeleted = image.IsDeleted;
                        dBContext.Entry(propImage).State = EntityState.Modified;
                    }
                }
            }

            #endregion 

            Save();
        }

        public List<PropertyDisplay> GetDisplay()
        {
            List<Property> props = GetAll();
            return GetDisplayDetails(props);
        }

        public List<PropertyDisplay> GetDisplay(Func<Property, bool> where)
        {
            List<Property> props;
            if (where != null)
                props = Get(where);
            else
                props = GetAll();

            return GetDisplayDetails(props);
        }
        
        public List<PropertyDisplay> GetDisplay(PropertySearch search)
        {
            //return GetDisplayDetails(dBContext.Properties.ToList());

            //StreamWriter SW = new StreamWriter(@"c:\temp\SearchData.txt", true);
            //SW.WriteLine(string.Format("{0:yyyy-MM-dd hh:mm:ss} - {1}", DateTime.Now, JsonConvert.SerializeObject(search)));
            //SW.Close();

            SearchObject obj = new SearchObject()
            {
                UserName = search.UserName,
                Type = "Property"
            };

            if (!string.IsNullOrEmpty(search.Keyword) && search.Keyword.ToUpper() != "ALL" && search.Keyword.ToUpper() != "UNDEFINED")
            {
                string keyword = search.Keyword.ToLower();

                List<Property> props = (from p in dBContext.Properties
                                        join pr in dBContext.Provinces on p.ProvinceId equals pr.Id
                                        join c in dBContext.Cities on p.CityId equals c.Id
                                        join s in dBContext.Suburbs on p.SuburbId equals s.Id
                                        join pt in dBContext.PropertyTypes on p.PropertyTypeId equals pt.Id
                                        where EF.Functions.Like(p.PropertyName.ToLower(), $"%{keyword}%")
                                        || EF.Functions.Like(pr.Description.ToLower(), $"%{keyword}%")
                                        || EF.Functions.Like(c.Description.ToLower(), $"%{keyword}%")
                                        || EF.Functions.Like(s.Description.ToLower(), $"%{keyword}%")
                                        || EF.Functions.Like(pt.Description.ToLower(), $"%{keyword}%")
                                        select p).ToList();
                obj.Property = "Keyword";
                obj.Value = search.Keyword;
                SaveLog(obj);

                return GetDisplayDetails(props);
            }
            else
            {
                List<Property> props;

                //Property ID search will override other searches. 
                if (search.PropertyId > 0)
                {
                    obj.Property = "PropertyID";
                    obj.Value = search.PropertyId.ToString();
                    SaveLog(obj);

                    props = dBContext.Properties.Where(p => p.Id == search.PropertyId).ToList();
                    return GetDisplayDetails(props);
                }

                PropertyUsageType uType = PropertyUsageType.Both;

                if (!string.IsNullOrEmpty(search.PropertyUsageType) && search.PropertyUsageType != "undefined" && search.PropertyUsageType.ToUpper() != "ALL")
                {
                    if (search.PropertyUsageType.ToUpper() == "COMMERCIAL")
                        uType = PropertyUsageType.Commercial;
                    else
                        uType = PropertyUsageType.Residential;
                }
                props = (from p in dBContext.Properties
                         join pt in dBContext.PropertyTypes on p.PropertyTypeId equals pt.Id
                         where pt.UsageType == uType
                         select p).ToList();

                obj.Property = "PropertyUsageType";
                obj.Value = search.PropertyUsageType;
                SaveLog(obj);

                if (!string.IsNullOrEmpty(search.SalesType) && search.SalesType != "undefined" && search.SalesType.ToUpper() != "ALL")
                {
                    if (search.SalesType.ToUpper() == "SALE")
                    {
                        props = props.Where(p => p.IsSale).ToList();
                        search.AvailableFrom = DateTime.MinValue; //Sales do not have an available from date. 
                    }
                    else
                        props = props.Where(p => !p.IsSale).ToList();

                    obj.Property = "SalesType";
                    obj.Value = search.SalesType;
                    SaveLog(obj);
                }

                if (!string.IsNullOrEmpty(search.Province) && search.Province != "undefined" && search.Province.ToUpper() != "ALL")
                {
                    props = (from p in props
                             join pp in dBContext.Provinces on p.ProvinceId equals pp.Id
                             where pp.Description.ToUpper() == search.Province.ToUpper()
                             select p).ToList();

                    obj.Property = "Province";
                    obj.Value = search.Province;
                    SaveLog(obj);
                }

                if (!string.IsNullOrEmpty(search.City) && search.City != "undefined" && search.City.ToUpper() != "ALL")
                {
                    props = (from p in props
                             join c in dBContext.Cities on p.CityId equals c.Id
                             where c.Description.ToUpper() == search.City.ToUpper()
                             select p).ToList();

                    obj.Property = "City";
                    obj.Value = search.City;
                    SaveLog(obj);
                }

                if (!string.IsNullOrEmpty(search.Suburb) && search.Suburb != "undefined" && search.Suburb.ToUpper() != "ALL")
                {
                    props = (from p in props
                             join s in dBContext.Suburbs on p.SuburbId equals s.Id
                             where s.Description.ToUpper() == search.Suburb.ToUpper()
                             select p).ToList();

                    obj.Property = "Suburb";
                    obj.Value = search.Suburb;
                    SaveLog(obj);
                }
                if (!string.IsNullOrEmpty(search.PropertyType) && search.PropertyType != "Undefined" && search.PropertyType.ToUpper() != "ALL")
                {
                    var pType = dBContext.PropertyTypes.Where(t => t.Description == search.PropertyType).FirstOrDefault();
                    if (pType != null)
                    {
                        props = props.Where(p => p.PropertyTypeId == pType.Id).ToList();
                    }

                    obj.Property = "PropertyType";
                    obj.Value = search.PropertyType;
                    SaveLog(obj);
                }
                if (search.MinPrice > 0)
                {
                    props = props.Where(p => p.Price >= search.MinPrice).ToList();

                    obj.Property = "MinPrice";
                    obj.Value = search.MinPrice.ToString();
                    SaveLog(obj);
                }
                if (search.MaxPrice > 0)
                {
                    props = props.Where(p => p.Price <= search.MaxPrice).ToList();

                    obj.Property = "MaxPrice";
                    obj.Value = search.MaxPrice.ToString();
                    SaveLog(obj);
                }

                if (search.AvailableFrom != DateTime.MinValue)
                {
                    props = props.Where(p => p.DateAvailable.Date >= search.AvailableFrom.Date).ToList();

                    obj.Property = "AvailableFrom";
                    obj.Value = search.AvailableFrom.ToString();
                    SaveLog(obj);
                }

                return GetDisplayDetails(props);
            }
        }        

        private void SaveLog(SearchObject item)
        {
            var searchLog = new SearchLog
            {
                Type = item.Type,
                Search = JsonConvert.SerializeObject(item)
            };            
            dBContext.SearchLogs.Add(searchLog);
            Save();
        }

        private List<PropertyDisplay> GetDisplayDetails(List<Property> props)
        {
            var properties = new List<PropertyDisplay>();
            props = props.Where(p => p.Published).ToList();
            foreach (var item in props)
            {                
                PropertyDisplay display = new PropertyDisplay
                {          
                    DateAvailable = item.DateAvailable,
                    Available = item.DateAvailable.Date > DateTime.Now.Date ? string.Format("Available form: {0: dd MMM yyyy}", item.DateAvailable) : "Available Now",
                    Id = item.Id,
                    ShortDescription = item.ShortDescription,
                    IsSale = item.IsSale,
                    DisplayPrice = string.Format("R {0}", item.Price.ToString("N0")),
                    DisplayImage = (from i in dBContext.PropertyImages
                                    where i.PropertyId == item.Id
                                    && i.IsDefault
                                    select i.Image).FirstOrDefault(),
                    Area = (from u in dBContext.PropertyUserFields
                            join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
                            where u.PropertyId == item.Id
                            && f.FieldName == "Floor Size"
                            select u.Value).FirstOrDefault(),
                    Beds = (from u in dBContext.PropertyUserFields
                            join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
                            where u.PropertyId == item.Id
                            && f.FieldName == "Bedrooms"
                            select u.Value).FirstOrDefault(),
                    Baths = (from u in dBContext.PropertyUserFields
                             join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
                             where u.PropertyId == item.Id
                             && f.FieldName == "Bathrooms"
                             select u.Value).FirstOrDefault(),
                    Garages = (from u in dBContext.PropertyUserFields
                               join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
                               where u.PropertyId == item.Id
                               && f.FieldName == "Garages"
                               select u.Value).FirstOrDefault(),
                    Province = (from p in dBContext.Provinces
                                where p.Id == item.ProvinceId
                                select p.Description).FirstOrDefault(),
                    City = (from c in dBContext.Cities
                            where c.Id == item.CityId
                            select c.Description).FirstOrDefault(),
                    Suburb = (from s in dBContext.Suburbs
                              where s.Id == item.SuburbId
                              select s.Description).FirstOrDefault(),
                    Price = item.Price,
                    DateCreated = item.Created,
                    PropertyUsageType = (from p in dBContext.PropertyTypes
                                         where p.Id == item.PropertyTypeId
                                         select p.UsageType.ToString()).FirstOrDefault(),
                    HasPendingOffer = !MayEdit(item.Id)
                };

                if (display.DisplayImage != null && !display.DisplayImage.StartsWith("data:image"))
                {
                    display.DisplayImage = ImageFormatter.ImageToBase64(display.DisplayImage);
                }

                if (!string.IsNullOrEmpty(display.Area) && display.Area.EndsWith("2"))
                {
                    display.Area = display.Area.Substring(0, display.Area.Length - 1) + "<sup>" + display.Area.Last() + "</sup>";
                }

                if (display.HasPendingOffer)
                    display.Available = "Offer Pending";
#if !ReturnImages
                display.DisplayImage = "";
#endif
                properties.Add(display);
            }

            return properties;
        }

        public List<PropertyType> GetPropertyTypes(Func<PropertyType, bool> where)
        {
            List<PropertyType> list;
            if (where != null)
                list = dBContext.PropertyTypes.Where(where).ToList();
            else
                list = dBContext.PropertyTypes.ToList();

            return list;
        }

        public List<PropertyDisplay> GetLatestDisplay()
        {
            List<Property> props = GetAll().Where(x => x.Published).OrderByDescending(x => x.DatePublished).Take(3).ToList();
            return GetDisplayDetails(props);
        }

        public List<PropertyList> GetPropertyList(int By)
        {
            List<Property> properties = new List<Property>();
            var user = dBContext.Users.Where(u => u.Id == By).FirstOrDefault();
            if (user != null)
            {
                if (user.Role.ToUpper() == "AGENCY" || user.Role.ToUpper() == "AGENT")
                {
                    var agent = dBContext.Agents.Where(a => a.UserId == user.Id).FirstOrDefault();
                    if (user.Role.ToUpper() == "AGENCY")
                    {
                        properties = dBContext.Properties.Where(p => p.AgencyId == agent.AgencyId).ToList();
                    }
                    else
                    {
                        properties = dBContext.Properties.Where(p => p.AgentId == agent.Id).ToList();
                    }
                }
                if (user.Role.ToUpper() == "PRIVATE USER")
                {
                    var individual = dBContext.Individuals.Where(i => i.UserId == user.Id).FirstOrDefault();

                    properties = dBContext.Properties.Where(p => p.OwnerId == individual.Id).ToList();
                }
                if (user.Role.ToUpper() == "SUPER ADMIN")
                    properties = dBContext.Properties.Include("City").Include("Suburb").ToList();
            }

            return SetPropertyList(properties);
        }

        public List<PropertyList> GetPropertyList()
        {
            return SetPropertyList(dBContext.Properties.Where(x => x.Published).ToList());
        }

        private List<PropertyList> SetPropertyList(List<Property> properties)
        {
            List<PropertyList> list = new List<PropertyList>();

            foreach (Property p in properties)
            {
                var prop = new PropertyList()
                {
                    Id = p.Id,
                    Name = string.IsNullOrEmpty(p.PropertyName) ? p.ShortDescription : p.PropertyName,
                    Price = p.Price,
                    Publish = p.Published ? "Yes" : "No",
                    Type = dBContext.PropertyTypes.Find(p.PropertyTypeId)?.Description,
                    CarouselDescription = string.Format("{0}, {1} <br/>{2}", p.Suburb?.Description, p.City?.Description, p.AddressLine3),
                    DateAvailable = p.IsSale ? DateTime.MinValue : p.DateAvailable,
                    IsPublished = p.Published
                };

                prop.Size = (from u in dBContext.PropertyUserFields
                             join f in dBContext.UserDefinedFields on u.UserDefinedFieldId equals f.Id
                             where u.PropertyId == p.Id
                             && f.FieldName == "Floor Size"
                             select u.Value).FirstOrDefault();

                if (!string.IsNullOrEmpty(prop.Size) && prop.Size.EndsWith("2"))
                {
                    prop.Size = prop.Size.Substring(0, prop.Size.Length - 1) + "<sup>" + prop.Size.Last() + "</sup>";
                }

                prop.UsageType = (dBContext.PropertyTypes.Find(p.PropertyTypeId).UsageType == PropertyUsageType.Residential ? "Residential" : "Commercial");
                prop.SaleType = p.IsSale ? "Sale" : "Rental";

                list.Add(prop);
            }

            return list;
        }

        public int NewId()
        {
            // Not sure if properties need it
            return 0;
        }

        public void Insert(PropertyContainer items)
        {
            Property property = new Property();            
            PropertyType pt = dBContext.PropertyTypes.Find(items.PropertyTypeId);
            if (pt != null)
            {
                if (pt.UsageType == PropertyUsageType.Residential)
                {
                    string type = dBContext.PropertyTypes.Find(items.PropertyTypeId).Description;
                    if (items.PropertyUserFields.Count > 0)
                    {
                        string shortDesc = "{0} {1} {2}";
                        UserDefinedField bedrooms = dBContext.UserDefinedFields.Where(u => u.FieldName == "Bedrooms").FirstOrDefault();
                        var udValue = items.PropertyUserFields.Where(u => u.UserDefinedFieldId == bedrooms.Id).FirstOrDefault();
                        if (udValue != null)
                            items.ShortDescription = string.Format(shortDesc, udValue.Value, "Bedroom", pt.Description).Trim();
                        else
                            items.ShortDescription = string.Format(shortDesc, "", "", pt.Description).Trim();
                    }
                    else
                    {
                        items.ShortDescription = type;
                    }
                }
                else
                {
                    items.ShortDescription = pt.Description;
                }
            }

            var images = items.PropertyImages;
            var fields = items.PropertyUserFields;

            items.PropertyImages = null;
            items.PropertyUserFields = null;

            var individual = dBContext.Individuals.Where(i => i.UserId == items.UserId).FirstOrDefault();
            var agent = dBContext.Agents.Where(a => a.UserId == items.UserId).FirstOrDefault();
            var status = dBContext.Status.Where(a => a.Code == "P1").FirstOrDefault();

            foreach( string prop in property.GetAllProperties())
            {
                if (prop != "Item" && prop != "Display")
                    property[prop] = items[prop];
            }

            if (individual != null)
                property.OwnerId = individual.Id;
            if (agent != null)
            {
                property.AgencyId = agent.AgencyId;
                property.AgentId = agent.Id;
            }            

            if (status != null)
                property.StatusId = status.Id;

            property.Video = property.Video.Replace("https://www.youtube.com/watch?v=", "");

            if (images != null)
            {
                bool saveFiles = false;
                var loc = dBContext.Location.FirstOrDefault()?.PropertyImageLocation;
                if (!string.IsNullOrEmpty(loc))
                {
                    saveFiles = true;
                    loc += string.Format("\\{0}", property.Id);
                    if (Directory.Exists(loc))
                    {
                        Directory.CreateDirectory(loc);
                    }
                }

                property.PropertyImages = new List<PropertyImage>();
                var lastID = dBContext.PropertyImages.Max(i => i.Id) + 1;
                foreach (PropertyImage image in images)
                {
                    image.PropertyId = property.Id;
                    if (saveFiles)
                    {
                        string path = ImageFormatter.Base64ToImage(image.Image, loc, lastID.ToString());
                        image.Image = path;
                    }
                    property.PropertyImages.Add(image);
                    lastID++;
                }
            }

            if (fields != null)
            {                
                property.PropertyUserFields = new List<PropertyUserField>();
                foreach (PropertyUserField field in fields)
                {
                    field.PropertyId = property.Id;
                    property.PropertyUserFields.Add(field);
                }
            }

            dBContext.Properties.Add(property);
            Save();

            items.Id = property.Id;            
        }

        public bool MayEdit(int id)
        {
            var hasBidItems = (from b in dBContext.BidItems
                               where b.PropertyId == id
                               && b.StatusId == 2
                               select b).FirstOrDefault();

            return (hasBidItems == null) ? true : false;
        }

        public void InsertImages(int propertyID, List<PropertyImage> Images)
        {
            if (Images != null)
            {
                var lastID = dBContext.PropertyImages.Max(i => i.Id) + 1;

                bool saveFiles = false;
                var loc = dBContext.Location.FirstOrDefault()?.PropertyImageLocation;
                if (!string.IsNullOrEmpty(loc))
                {
                    saveFiles = true;
                    loc += string.Format("\\{0}", propertyID);
                    if (Directory.Exists(loc))
                    {
                        Directory.CreateDirectory(loc);
                    }
                }

                foreach (PropertyImage image in Images)
                {                                    
                    image.PropertyId = propertyID;
                    if (saveFiles)
                    {
                        string path = ImageFormatter.Base64ToImage(image.Image, loc, lastID.ToString());
                        image.Image = path;
                    }
                    dBContext.PropertyImages.Add(image);
                    lastID++;
                    Save();
                }
            }
        }

        public void InsertFields(int propertyID, List<PropertyUserField> Fields)
        {
            throw new NotImplementedException();
        }

        public void PublishProperty(int propertyID)
        {
            var property = dBContext.Properties.Where(p => p.Id == propertyID).FirstOrDefault();
            if (property != null)
            {
                property.Published = true;
                property.DatePublished = DateTime.Now;
                Update(property);
            }
        }

        public void UnpublishProperty(int propertyID)
        {
            var property = dBContext.Properties.Where(p => p.Id == propertyID).FirstOrDefault();
            if (property != null)
            {
                property.Published = false;
                property.DatePublished = DateTime.MinValue;
                Update(property);
            }
        }        
    }
}