How to convert buildmode script to be used in multiplayer?

So I have a buildmode script to be used to build towers/buiildings which works in single player but if i try to use it with UNet the building only show up for the client. I've been googling around and reading the manual but can't figure out how to transfer the script so it can be used in a multiplayer environment. Any help would be greatly appreciated!

Being fairly new please bare with me.

Here is the buildmode script I am working with:

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.Networking;
 
 public class TowerInfo
 {
     public GameObject TowerObject { set; get; }
     public BaseTower Tower { set; get; }
     public Vector3 Position { set; get; }
     public bool IsOccupied { set; get; }
 }
 
 public class BuildMode : NetworkBehaviour
 
 {
 
     private const float PREVIEW_DISTANCE_FROM_PLAYER = 3.0f;
 
     public List<GameObject> towerPrefabs;
 
     private int selectedTowerIndex = 0;
     private TowerInfo focusedTowerSpawn;
     private List<TowerInfo> towerSpawns;
     private Transform playerTransform;
     private Transform CameraTransform;
     private GameObject spawnPreview;
 
     private bool isActive = false;
 
     private void Start()
     {
         towerSpawns = new List<TowerInfo>();
         // Get all the tower info in the map
         foreach(GameObject go in GameObject.FindGameObjectsWithTag("TowerSpawn"))
         {
             towerSpawns.Add(new TowerInfo
             {
                 Position = go.transform.position,
                 IsOccupied = false
             });
         }
 
         // Creat the Tower preview
         OnSelectionChanged();
     }
 
     private void Update()
     {
         PoolInput();
 
         if (!isActive)
             return;
 
         MoveSpawnPreview();
     }
 
     private void SpawnTower()
     {
         if (focusedTowerSpawn == null)
             return;
 
         if (focusedTowerSpawn.IsOccupied == true)
             return;
 
         // If Enough Resources
 
         focusedTowerSpawn.TowerObject = Instantiate(towerPrefabs[selectedTowerIndex], focusedTowerSpawn.Position, Quaternion.identity) as GameObject;
         focusedTowerSpawn.Tower = focusedTowerSpawn.TowerObject.GetComponent<BaseTower>();
         focusedTowerSpawn.IsOccupied = true;
 
         
     }
 
     private void OnSelectionChanged()
     {
         Destroy(spawnPreview);
         spawnPreview = Instantiate(towerPrefabs[selectedTowerIndex]) as GameObject;
         spawnPreview.GetComponent<BaseTower>().enabled = false;
         spawnPreview.GetComponent<Collider>().enabled = false;
     }
 
     private void MoveSpawnPreview()
     {
         if (playerTransform == null || CameraTransform == null)
         {
             playerTransform = GameObject.FindGameObjectWithTag("Player").transform;
                             // GameObject.FindGameObjectWithTag ("MainCamera");
             CameraTransform = Camera.main.transform;
             return;
         }
 
 
         Vector3 previewPosition = playerTransform.position;
         previewPosition += (playerTransform.position - CameraTransform.position).normalized * PREVIEW_DISTANCE_FROM_PLAYER;
         RaycastHit hit;
         if (Physics.Raycast(previewPosition + Vector3.up * 5, Vector3.down, out hit, 10.0f, LayerMask.GetMask("Ground")))
             previewPosition.y = hit.point.y;
 
         //preview position is build range
         Collider[] towerSpawnColliders = Physics.OverlapSphere(previewPosition, 4.0f, LayerMask.GetMask("TowerSpawn"));
         if(towerSpawnColliders.Length > 0)
         {
             float closestDistanceSqr = Vector3.SqrMagnitude(previewPosition - towerSpawnColliders[0].transform.position);
             int closestIndex = 0;
             for(int i = 1; i < towerSpawnColliders.Length; i++)
             {
                 float d = Vector3.SqrMagnitude(previewPosition - towerSpawnColliders[i].transform.position);
                 if (d < closestDistanceSqr)
                 {
                     closestDistanceSqr = d;
                     closestIndex = i;
                 }
             }
 
 
             focusedTowerSpawn = towerSpawns.Find(t => t.Position == towerSpawnColliders[closestIndex].transform.position);
             previewPosition = focusedTowerSpawn.Position;
         }
         else
         {
             focusedTowerSpawn = null;
         }
 
 
         spawnPreview.transform.position = previewPosition;
     }
 
 
     private void PoolInput()
     {
         // Activate / Deactivate BuildMode
         if (Input.GetKeyDown(KeyCode.R))
         {
             if (isActive)
                 DisableBuildMode();
             else
                 ActivateBuildMode();
         }
 
         // Change Tower Selection
         if (isActive)
         {
             if(Input.GetKeyDown (KeyCode.Q))
             {
                 if(selectedTowerIndex > 0)
                 {
                     selectedTowerIndex--;
                     OnSelectionChanged();
                 }
             }
 
             if (Input.GetKeyDown(KeyCode.E))
             {
                 if (selectedTowerIndex < towerPrefabs.Count - 1)
                 {
                     selectedTowerIndex++;
                     OnSelectionChanged();
                 }
             }
         }
 
         // Spawn the Tower
         if (isActive)
         {
             if(Input.GetKeyDown (KeyCode.F))
             {
                 SpawnTower();
             }
         }
     }
 
     private void ActivateBuildMode()
     {
         isActive = true;
         spawnPreview.active = true;
     }
 
     private void DisableBuildMode()
     {
         isActive = false;
         spawnPreview.active = false;
     }
 }